Python基础知识入门（三）_小言_互联网的博客

Python基础知识入门（三）

2022-11-26 17:04 264人阅读评论(0)

Python基础知识入门（一）

Python基础知识入门（二）

一、元组类型

元组是用英文小括号 () 把所有元素包裹起来，元组里面的每一个数据叫作元素。每个元素之间都要用英文逗号 ( , ) 隔开。例如：(1,2,3)。

注意：

元组是不可变数据类型，不可以进行“增删改”操作，但可通过拼接、切片完成“增删改”操作。

1.元组函数

序号	函数名	方法及描述
1	tuple(x)	将可迭代对象x转换为元组。 x = [1, 2, 3 ,4, 5]，tuple(x)，返回 (1, 2, 3, 4, 5)。
2	len(x)	计算元组x元素个数。 x = (1, 2, 3 ,4, 5)，len(x)，返回 5。
3	max(x)	返回元组x中元素最大值。 x = (1, 2, 3 ,4, 5) ，max(x) 返回 5。
4	min(x)	返回元组x中元素最小值。 x = (1, 2, 3 ,4, 5) ，min(x) 返回 1。
5	count(x)	返回元素x在元组出现次数 x = (1, 3, 3 ,3, 5)，x.count(3)，返回 3。
6	index(x)	从元组中找出某个值第一个匹配项的索引位置。 x = (1, 2, 3 ,3, 5)，x.count(3)，返回 2。
7	zip(x,y)	将两个列表组合为元组，再用list函数转为列表。 x = [1,2,3]，y = [4,5,6]，list(zip(x,y))，返回 [(1, 4), (2, 5), (3, 6)]。
8	enumerate(x[,y])	将列表内容和序号组合为元组对象，再利用list函数转为列表。 x = ['A','B','C']，list(enumerate(x))，返回[(0, 'A'), (1, 'B'), (2, 'C')] list(enumerate(x,1))，返回 [(1, 'A'), (2, 'B'), (3, 'C')] y 为起始序号。

2.元组切片


  
   
    
     
    
    
     
      x = (
      1, 
      2, 
      3, 
      4, 
      5, 
      6)
     
    
   
    
     
    
    
     
      print(x[
      2])             
      # 3 查找元组下标为2的元素
     
    
   
    
     
    
    
     
      print(x[-
      2])            
      # 5 查找元组倒数第2个元素
     
    
   
    
     
    
    
     
      print(x[:])             
      # (1, 2, 3, 4, 5, 6) 查找元组下标为0到末尾的元素
     
    
   
    
     
    
    
     
      print(x[::
      2])           
      # (1, 3, 5) 查找元组下标0到末尾间隔为2的元素
     
    
   
    
     
    
    
     
      print(x[:
      5])            
      # (1, 2, 3, 4, 5) 查找元组下标为0到5的元素
     
    
   
    
     
    
    
     
      print(x[
      1:])            
      # (2, 3, 4, 5, 6) 查找元组下标为1到末尾的元素
     
    
   
    
     
    
    
     
      print(x[
      1:-
      2])          
      # (2, 3, 4) 查找元组下标1的到倒数第2个间的元素
     
    
   
    
     
    
    
     
      print(x[-
      5:-
      3])         
      # (2, 3) 查找元组倒数第5到倒数第3间的元素

3.元组运算


  
   
    
     
    
    
     
      x = (
      1, 
      2, 
      3)
     
    
   
    
     
    
    
     
      y = (
      4, 
      5, 
      6)
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      print(
      len(x))       
      # 3 计算元组元素个数
     
    
   
    
     
    
    
     
      print(x + y)        
      # (1, 2, 3, 4, 5, 6) 元组 x 和元组 y 拼接
     
    
   
    
     
    
    
     
      print(x*
      2)          
      # (1, 2, 3, 1, 2, 3) 复制指定系数元组 x
     
    
   
    
     
    
    
     
      print(
      5 
      in y)       
      # True 判断 5 是否在元组 x 内
     
    
   
    
     
    
    
     
      print(
      5 
      not 
      in y )  
      # False 判断 5 是否不在元组 x 内
     
    
   
    
     
    
    
     
      print(x!=y)         
      # True 判断元组 x 和 y 是否相等

二、字典类型

字典是由大括号 {} 包裹所有元素。字典的每个元素是键值对，中间用英文冒号连接（:）如 {'name': '漫步桔田'}，其中我们把 'name' 叫键（key），' 漫步桔田' 值（value）。

1.字典函数

序号	函数名	方法及描述
1	diact(x)	创建一个字典。序列x必须是元组。 x = (('漫漫',23),) y = dict(x)，返回 y = {'漫漫': 23}。
2	len(x)	计算字典x元素个数，即键的总数。 x = {'name':'漫步桔田','age':21}，len(x)，返回 2 。
3	max(x)	返回字典中键的最大值。 x = {'a':1,'b':2,'c':3}，max(x)，返回 c。 y = {'101':1,'201':2,'301':3}，max(y)，返回 3。
4	min(x)	返回字典中键的最小值。 x = {'a':1,'b':2,'c':3}，min(x)，返回 a。 y = {'101':1,'201':2,'301':3}，min(y)，返回 101。
5	clear()	删除字典内所有元素。 x = {'name':'漫步桔田','age':21}，x.clear()，返回 x = {}。
6	copy()	返回一个字典的浅复制。 x = {'name':'漫步桔田','age':21}，y = x.copy()，返回 y = {'name':'漫步桔田','age':21}。
7	fromkeys()	dict.fromkeys(seq[, value]) seq -- 字典键值列表。 value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值。 y = [1,2,3]，dict.fromkeys(y)，返回{1: None, 2: None, 3: None} dict.fromkeys(y,6) ，返回 {1: 6, 2: 6, 3: 6}。
8	update()	把字典dict2的键/值对更新到dict里。 x = {'name':'漫步桔田','age':21} y = {'results':100} x.update(y) 返回 x = {'name': '漫步桔田', 'age': 21, 'results': 100}。
9	get()	dict.get(key,default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值。 x = {'name':'漫步桔田','age':21} x.get('name') 返回漫步桔田。 x.get(123) 返回 None。 x.get(123,456) 返回 456。
10	setdefault()	dict.setdefault(key,default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default。 x = {'name':'漫步桔田','age':21} x.setdefault('name') 返回漫步桔田。 x.setdefault('results',100) 返回 100。 x = {'name': '漫步桔田', 'age': 21, 'results': 100}。
11	items()	返回一个视图对象。 x = {'name':'漫步桔田','age':21} x.items() 返回 dict_items([('name', '漫步桔田'), ('age', 21)])。
12	keys()	返回一个视图对象。 x = {'name':'漫步桔田','age':21} x.keys() 返回 dict_keys(['name', 'age'])。
13	values()	返回一个视图对象。 x = {'name':'漫步桔田','age':21} x.values() 返回 dict_values(['漫步桔田', 21])。
14	pop()	删除字典 key（键）所对应的值，返回被删除的值。 x = {'name':'漫步桔田','age':21} x.pop('name') 返回 x = {'age': 21}。
15	popitem()	返回并删除字典中的最后一对键和值。 x = {'name':'漫步桔田','age':21} x.popitem() 返回 x = {'name': '漫步桔田'}。

2.字典操作


  
   
    
     
    
    
     
      # 字典创建
     
    
   
    
     
    
    
     
      x = 
      dict(name =
      '漫步桔田',age = 
      21)
     
    
   
    
     
    
    
     
      print(x)               
      # {'name': '漫步桔田', 'age': 21} 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      name = [
      '漫漫',
      '桔桔']
     
    
   
    
     
    
    
     
      age = [
      23,
      21]
     
    
   
    
     
    
    
     
      x = 
      dict(
      zip(name,age))
     
    
   
    
     
    
    
     
      print(x)               
      # {'漫漫': 23, '桔桔': 21}
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 字典增加
     
    
   
    
     
    
    
     
      x = {
      'name':
      '漫步桔田',
      'age':
      21}
     
    
   
    
     
    
    
     
      x[
      'scores'] = 
      100
     
    
   
    
     
    
    
     
      print(x)               
      # {'name': '漫步桔田', 'age': 21, 'scores': 100} 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 字典删除
     
    
   
    
     
    
    
     
      x = {
      'name':
      '漫步桔田',
      'age':
      21}
     
    
   
    
     
    
    
     
      del x[
      'age']
     
    
   
    
     
    
    
     
      print(x)               
      # {'name': '漫步桔田'} 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 字典修改
     
    
   
    
     
    
    
     
      x = {
      'name':
      '漫步桔田',
      'age':
      21}
     
    
   
    
     
    
    
     
      x[
      'age'] = 
      25
     
    
   
    
     
    
    
     
      print(x)               
      # {'name': '漫步桔田', 'age': 25} 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 字典查询
     
    
   
    
     
    
    
     
      x = {
      'name':
      '漫步桔田',
      'age':
      21}
     
    
   
    
     
    
    
     
      print(x[
      'age'])        
      # 21 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 字典嵌套
     
    
   
    
     
    
    
     
      x = {}
     
    
   
    
     
    
    
     
      x[
      'name'] = [
      1,
      2,
      3]   
     
    
   
    
     
    
    
     
      print(x)              
      # {'name': [1, 2, 3]}
     
    
   
    
     
    
    
     
      print(x[
      'name'][
      1])   
      # 2 嵌套取值 
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 字典判断
     
    
   
    
     
    
    
     
      x = {
      '漫漫': 
      23, 
      '桔桔': 
      21}  
     
    
   
    
     
    
    
     
      print(
      '漫漫' 
      in x)     
      # True 判断字典键中是否包含'漫漫'
     
    
   
    
     
    
    
     
      print(
      '小漫' 
      in x)     
      # False 判断字典键中是否包含'小漫'

三、集合类型

集合是一个无序不重复的序列。使用大括号 { } 或者 set() 函数创建集合。例如：{1,2,3}。

注意：

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1.集合函数

序号	函数名	方法及描述
1	set()	将序列转换为集合。 x = [1,2,3]，set(x)，返回 {1, 2, 3} 。 y = (4,5,6)，set(y)，返回 {4, 5, 6} 。
2	len()	计算集合中元素个数。 x = {1,2,3}，len(x))，返回 3 。
3	max()	返回集合中最大值。 x = {1,2,3}，max(x)，返回 3 。 y = {'a','b','c'}，max(x)，返回 c 。
4	min()	返回集合中最小值。 x = {1,2,3}，min(x)，返回 1 。 y = {'a','b','c'}，min(x)，返回 a 。
5	add()	为集合添加新元素。 x = {1,2,3,4,5} x.add(6) 返回 x = {1,2,3,4,5,6}。
6	union()	返回两个集合的并集。 x = {1,3,5} y = {5,7} x.union(y)，返回 {1, 3, 5, 7}。
7	intersection()	返回集合的交集。 x = {1,3,5} y = {2,3,4} z = x.intersection(y)，返回 z = {3}。
8	update()	将集合 y 中元素过滤掉相同元素后添加到集合 x 中。 x = {1,3,5} y = {5,7} x.update(y)，返回 x = {1, 3, 5, 7}。
9	clear()	移除集合中的所有元素。 x = {1,2,3,4,5} x.clear()，返回 x = set()。
10·	copy()	拷贝一个集合。 x = {1,2,3,4,5} y = x.copy()，返回y = {1,2,3,4,5}。
11	pop()	随机移除元素。 x = {1,2,3,4,5} x.pop()，返回 x = {2, 3, 4, 5}。
12	remove()	移除指定元素。 x = {1,2,3,4,5} x.remove(4)，返回 x = {1, 2, 3, 5}。
13	discard()	删除集合中指定的元素。 x = {1,3,5} y = {2,3,4}，x.discard(3)，返回 x = {1, 5}。
14	difference_update()	删除x集合中与y集合中相同的元素。 x = {1,3,5} y = {2,3,4} x.difference_update(y)，返回x = {1, 5}。
15	intersection_update()	删除集合 x 中与指定集合 y 中不同元素。 x = {1,3,5} y = {2,3,4} x.intersection_update(y)，返回 x = {3}。
16	difference()	返回仅存在于集合 x 中而不存在于集合 y 中的元素。 x = {1,2,3} y = {2,3,4} z = x.difference(y)，返回 z = 1。
17	symmetric_difference()	返回两个集合中不重复的元素集合。 x = {1,3,5} y = {3,5,7} z = x.symmetric_difference(y)，返回 z = {1, 7}。
18	symmetric_difference_update()	移除集合x、集合y中的相同元素，并将集合y中不同元素插入到集合x中。 x = {3,5} y = {5,7} x.symmetric_difference_update(y)，返回 x = {3, 7}。
19	isdisjoint()	判断集合x、y 是否包含相同的元素，是返回 True，否则返回 False。 x = {1,3,5} y = {2,3,4} x.isdisjoint(y)，返回 False。
20	issubset()	判断指定集合 x 是否为集合 y 的子集，是返回 True，否则返回 False。 x = {1,3,5} y = {1,3,5,7,9} x.issubset(y)，返回 True。
21	issuperset()	判断集合 y 是否包含指定集合 x，是返回 True，否则返回 False。 x = {1,3,5} y = {1,3,5,7,9}，y.issuperset(x)，返回 True。

2.集合操作


  
   
    
     
    
    
     
      x = {
      1,
      2,
      3}
     
    
   
    
     
    
    
     
      print(
      2 
      in x)         
      # True 判断元素 2 是否在集合 x 中
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      x = [
      1,
      1,
      2,
      3,
      5,
      5]
     
    
   
    
     
    
    
     
      print(
      list(
      set(x)))   
      # [1, 2, 3, 5] 列表、元组去重
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      x = {
      1,
      3,
      5}
     
    
   
    
     
    
    
     
      y = {
      2,
      3,
      4}
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      print(x-y)            
      # {1, 5} 
     
    
   
    
     
    
    
     
      #差集：返回一个新集合，包括集合 x 中与集合y不同元素。
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      print(x|y)            
      # {1, 2, 3, 4, 5} 
     
    
   
    
     
    
    
     
      #并集：返回一个新集合，包括集合 x 和集合 y 中所有元素。
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      print(x&y)            
      # {3} 
     
    
   
    
     
    
    
     
      #交集：返回一个新集合，仅包括集合 x 和 y 中相同的元素。
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      print(x^y)            
      # {1, 2, 4, 5} 
     
    
   
    
     
    
    
     
      #补集：返回一个新集合，仅包括集合 x 和 y 中的不同元素。

转载：https://blog.csdn.net/u013157570/article/details/127784795

查看评论

小言_互联网的博客

小言_互联网的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章