数据类型

整数(int) ,字符串(str),布尔值(bool),列表(list),元组(tuple),字典(dict),集合(set).

0、基本数据类型：

ASCII：1个字节表示，包含字母、数字、特殊字符；

Unicode ：开始是16位，现在升级以后是32位；

utf-8：最少用一个字节表示，英文用1个字节

欧洲用2个字节

中文用3个字节表示

gbk：中文用2个字节，英文用1个字节表示

0.1、 int类型

int 比较重要的是bit_length()：1个数据最少二进制表达位；

1、字符串类型（str）

1.1 单双引号木有任何区别，但是下面的情况需要注意，不能随便用单引号：

msg = "I‘m a teacher’"

1.2 多引号，就是多行字符串时候用：

1 msg  = '''
2 我是中国人
3 我是广东人
4 我是广州人
5 '''

View Code

1.3 字符串可以相加及相乘：

 1 m1 = "我要去西藏"
 2 m2 = "唱一曲天路"
 3 m3 = m1 + m2
 4 m4 = m2 * 4
 5 print(m3)
 6 print(m4)
 7 
 8 输出为：
 9 我要去西藏唱一曲天路
10 唱一曲天路唱一曲天路唱一曲天路唱一曲天路

View Code

注意：字符串相加，其实就是进行拼接；但是字符串只能跟字符串进行拼接，不能够与数字进行拼接。

2、格式化输出

2.1 %s就是代表字符串占位符，%d是数字占位符，如果是%d则表示必须输入数字。另外如果想表达50%类似这样带%输出的情况，那么在%后面再加一个%，表示转义

1 msg = "我是%s,年龄%d,目前学习进度为80%%"%('金鑫',18)
2 print(msg)

View Code

2.2 format的三种用法格式化输出

 1 #format的三种用法 格式化输出
 2 s = '我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('彭',25,'sport','彭')
 3 print(s)
 4 name = input('请输入名字：')
 5 s = '我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format(name,25,'sport')
 6 print(s)
 7 name = input('请输入名字：')
 8 s = '我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(age=25,name=name,hobby='sport')
 9 print(s)
10 
11 结果：
12 我叫彭，今年25，爱好sport，再说一下我叫彭
13 请输入名字：彭
14 我叫彭，今年25，爱好sport，再说一下我叫彭
15 请输入名字：彭
16 我叫彭，今年25，爱好sport，再说一下我叫彭

View Code

3、字符串的索引及切片

isdigit()：判定是否为全部是数字，返回bool值
isapha()：
isnumpha()：
startswith：判定以什么开头；

endswith：判定以什么结尾；
title ：首字母大写
center（）：居中，不够的空白或者指定字符填充；
strip（）lstrip rstrip：
split：
format ：格式化输出

repalce:字符串替换，repalce(old,new,count)

expandtabs：对于s = 'peng\tjun'中，自动在\t处的左边补8个空格；

find : 找出指定字符的下标，index = content.find('+')

capitalize()：把首字母改为大写。

 1 #字符串的索引及切片
 2 
 3 s = "pengJunFei"
 4 s1 = s.capitalize() #首字母大写
 5 print(s1)
 6 s2 = s.upper() #全部转为大写
 7 s3 = s.lower() #全部转为小写
 8 print(s2) #
 9 print(s3)
10 
11 s4 = "PengJunFei"
12 s5 = s4.swapcase() #大小写翻转
13 print(s5)
14 
15 s6 = "peng*jun fei-123&abcd$rrrr%ddfef"
16 s61 = s6.title() #把空格/特殊字符隔开的字符串首字母转为大写
17 print(s61)
18 
19 s7 = "jun"
20 s71 = s7.center(20,"*") #把目标字符串用相应的字符居中，没有第1个参数的话，则默认为空格。
21 print(s71)
22 
23 s8 = "peng\tjunfei\t555广东" #自动把前面的字符补足8位
24 s81 = s8.expandtabs()
25 print(s81)
26 
27 s9 = "peng广东junfei"
28 s92 = len(s9) #计算字符串长度，中文也是按一个来计算。
29 print(s92)
30 
31 s10 = "pengAAceng"
32 s11 = s10.startswith('pen') #判定字符串是否以xxx为开头
33 s12 = s10.startswith('g',3,5) #判定字符串的第3个字符开始，第5个字符结束的这一区间是否以'g'开头，其中5可以去掉
34                               #则默认为到结尾，即顾头不顾尾
35 print(s11)
36 print(s12)
37 
38 s20 = 'pengJUNfeigaaa'
39 s21 = s20.find('g') #选择找到相应字符的第1次出现的下标索引
40 print(s21,type(s21)) #type()是判定变量的数据类型
41 
42 
43 
44 
45 
46 
47 结果：
48 Pengjunfei
49 PENGJUNFEI
50 pengjunfei
51 pENGjUNfEI
52 Peng*Jun Fei-123&Abcd$Rrrr%Ddfef
53 ********jun*********
54 peng    junfei  555广东
55 12
56 True
57 True
58 3 <class 'int'>

View Code

 1 s20 = 'pengJUNfeigaaa'
 2 s21 = s20.find('g') #选择找到相应字符的第1次出现的下标索引
 3 s22 = s20.index('a') #找字符串中第一个出现所标字符的位置，如果没有则报错
 4 print(s21,type(s21)) #type()是判定变量的数据类型
 5 print(s22)
 6 
 7 
 8 结果：
 9 3 <class 'int'>
10 11

View Code

 1 s = "ABCDEFGHIJKLMN"
 2 
 3 s1 = s[0]
 4 print(s1)
 5 s2 = s[4]
 6 print(s2)
 7 s3 = s[0:4] #列表的切片，是顾头不顾尾，即尾那个数不计算在内
 8 print(s3)
 9 
10 s4 = s[0:-1]#切到倒数第1个
11 print(s4)
12 s5 = s[:] #没有指定，则全部
13 print(s5)
14 s6 = s[0:]#c从第0开始，一直到结束，其实s5是等价于s6的
15 print(s6)
16 
17 结果：
18 A
19 E
20 ABCD
21 ABCDEFGHIJKLM
22 ABCDEFGHIJKLMN
23 ABCDEFGHIJKLMN

View Code

1 s = "ABCDEFGHIJKLMN"
2 s7 = s[0:0]#就是没有取到任何值
3 print(s7)
4 
5 结果：
6        #结果为空，没有取到值

View Code

1 s = "ABCDEFGHIJKLMN"
2 s8 = s[0:5:2] #首、尾、步长：0就是首
3 print(s8)
4 
5 结果：
6 ACE

View Code

1 s = "ABCDEFGHIJKLMN"
2 s9 = s[4:0:-1]
3 print(s9)
4 
5 结果：
6 EDCB

View Code

1 s = "ABCDEFGHIJKLMN"
2 s10 = s[3::-1]
3 print(s10)
4 
5 结果：
6 DCBA

View Code

1 s = "ABCDEFGHIJKLMN"
2 s11 = s[3::-2] #反向切，且步长为2
3 print(s11)
4 
5 结果：
6 DB

View Code

1 s = "ABCDEFGHIJKLMN"
2 s12 = s[-1::-1]#从最后一个反向切，一直切到最开头，步长为1
3 print(s12)
4 
5 结果：
6 NMLKJIHGFEDCBA

View Code

1 s = "ABCDEFGHIJKLMN"
2 s13 = s[-2::-1]
3 print(s13) #从倒数第二个开始切，一直切到最开头，步长为1
4 
5 结果：
6 MLKJIHGFEDCBA

View Code

1 s = "ABCDEFGHIJKLMN"
2 s14 = s[::-1]
3 print(s14)
4 
5 结果：
6 NMLKJIHGFEDCBA

View Code

3.1 字符串的前后删除某个字符 strip()、lstrip()、rstrip()

 1 s1 = '   $pengJun###FEI##'
 2 s10 = s1.strip() # 在用户输入中，可以把前后的空格去掉,实际字符中间则删不掉
 3 print(s10)
 4 s11 = s1.strip('$')
 5 print(s11)
 6 s12 = s10.strip('$') #从头尾同时向中间找，找到里面的字符则删除，遇到非要找的字符则停止
 7 print(s12)
 8 s13 = s10.strip('$#')#中间三个###删不掉是因为从尾部往中间遇到了I，挡住了
 9 print(s13)
10 
11 #例如
12 username = input('请输入名字：').strip()
13 if username == '彭':
14     print('输入正确')
15 
16 结果：
17 $pengJun###FEI##
18    $pengJun###FEI##
19 pengJun###FEI##
20 pengJun###FEI
21 请输入名字：   彭    
22 输入正确

View Code

 1 # strip(), 从两边往中间删，遇到非指定要删字符则停止
 2 # rstrip(),从右边往中间删，左边不动
 3 # lstrip()，从左边往中间删，右边不动
 4 
 5 s1 = '&&peng&jun%%*fei***'
 6 s12 = s1.rstrip('%*%')
 7 s13 = s1.lstrip('&*')
 8 print(s12)
 9 print(s13)
10 
11 结果：
12 &&peng&jun%%*fei
13 peng&jun%%*fei***

View Code

3.2 计算字符串中指定字符的个数 count()

1 s1 = '&&peng&jun%%*fei***'
2 s11 = s1.count('&')# 查找指定字符的个数
3 print(s11)
4 
5 结果：
6 3

View Code

3.3 把字符串按字符串中某个字符进行分割，一分为二地分割为列表 split()

 1 #splint()是对按指定字符一分为二为列表
 2 s2 = '&& peng& jun%%* fei***'
 3 s21 = s2.split() #按空格一分为二为列表
 4 s22 = s2.split('&')#按&一分为二为列表
 5 print(s21)
 6 print(s22)
 7 
 8 结果：
 9 ['&&', 'peng&', 'jun%%*', 'fei***']
10 ['', '', ' peng', ' jun%%* fei***']

View Code

例子：加法计算器

 1 content = input('请输入加法计算式：').strip()
 2 print(content)
 3 content_conl = content.split('+')
 4 print(content_conl)
 5 sum = 0
 6 for i in content_conl:
 7     sum += int(i)
 8 print(sum)
 9 
10 结果：
11 请输入加法计算式：5+8+9   +6
12 5+8+9   +6
13 ['5', '8', '9   ', '6']
14 28

View Code

4、布尔值

1 while True:
2     pass
3 
4 比
5 
6 while 1:
7     pass
8 
9 要慢，因为True还得转换为1，增加了这个步骤则更多的耗时。

View Code

字符串转为布尔值：bool(str), 如果str为空则为False；如果不为空，哪怕为str里为0，结果为True。

5、列表(list)

列表的增删改查

5.1 增

append()：插入到列表的末尾

 1 #增加append
 2 #列表增加是直接增加，且加什么就是什么，即数字就是数字，加字符串就是字符串
 3 my_list = ['peng','li',"quan",'钟']
 4 
 5 while 1:
 6     name = input('请输入增加的名字：')
 7     if name.strip().upper() == 'Q':
 8         break
 9     else:
10         my_list.append(name)
11 print(my_list)
12 
13 结果：
14 请输入增加的名字：彭
15 请输入增加的名字：全
16 请输入增加的名字：钱三
17 请输入增加的名字：q
18 ['peng', 'li', 'quan', '钟', '彭', '全', '钱三']

View Code

insert()：插入到指定位置，即按索引去添加

1 my_list = ['peng','li',"quan",'钟']
2 my_list.insert(2,'广东')
3 print(my_list)
4 
5 结果：
6 ['peng', 'li', '广东', 'quan', '钟']

View Code

extend()：按可迭代的元素增加，添加到最后，即增加的数据必须是可迭代的，如果只是一个整数则不可增加，因其不可迭代

 1 my_list = ['peng','li',"quan",'钟']
 2 my_list.extend('abc')
 3 print(my_list)
 4 my_list.extend(['a','123','b,c,d'])
 5 print(my_list)
 6 my_list.extend('h')
 7 print(my_list)
 8 my_list.extend(25)
 9 
10 结果：
11 ['peng', 'li', 'quan', '钟', 'a', 'b', 'c']
12   File "E:/Python Project/05/Day4/List的增删改查.py", line 26, in <module>
13 ['peng', 'li', 'quan', '钟', 'a', 'b', 'c', 'a', '123', 'b,c,d']
14 ['peng', 'li', 'quan', '钟', 'a', 'b', 'c', 'a', '123', 'b,c,d', 'h']
15     my_list.extend(25)
16 TypeError: 'int' object is not iterable

View Code

5.2 删

pop() ：按索引去删除，有返回被删除值，如果没有输入参数则默认删除最后一个

1 my_list = ['peng','li',"quan",'钟']
2 #pop() ：按索引去删除，有返回被删除值，如果没有输入参数则默认删除最后一个，
3 my_list.pop(1)
4 print(my_list)
5 
6 结果：
7 ['peng', 'quan', '钟']

View Code

remove():按元素去删除，即输入具体要删除的元素

1 my_list = ['peng','li',"quan",'钟']
2 #remove()：按元素去删除，即输入具体要删除的元素
3 my_list.remove('quan')
4 print(my_list)
5 
6 结果：
7 ['peng', 'li', '钟']

View Code

clear()：清空列表

1 my_list = ['peng','li',"quan",'钟']
2 #clear()：清空列表
3 my_list.clear()
4 print(my_list)
5 
6 结果：
7 []

View Code

del ：切片的去删除

1 my_list = ['peng','li',"quan",'钟']
2 #del[] ：切片删除
3 del my_list[0:2]
4 print(my_list)
5 
6 结果：
7 ['quan', '钟']

View Code

1 my_list = ['peng','li',"quan",'钟']
2 #del[] ：切片删除
3 del my_list[2:]
4 print(my_list)
5 结果：
6 ['peng', 'li']

View Code

5.3 改

按索引改：

1 my_list = ['peng','li',"quan",'钟']
2 my_list[0] = 'zhang'
3 print(my_list)
4 结果：
5 ['zhang', 'li', 'quan', '钟']

View Code

按切片改：

1 my_list = ['peng','li',"quan",'钟']
2 #按切片去改
3 my_list[0:2] = ["a,b,c",'中国']
4 print(my_list)
5 
6 结果：
7 ['a,b,c', '中国', 'quan', '钟']

View Code

5.4 查

按切片去查：

1 my_list = ['peng','li',"quan",'钟']
2 
3 print(my_list[1:3])
4 结果：
5 ['li', 'quan']

View Code

6、公共方法

len()：统计列表元素长度

1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']
2 Len = len(my_list)
3 print(Len)
4 结果：
5 9

View Code

count()：统计指定元素的个数

1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']
2 num = my_list.count('钟') #统计指定元素的个数
3 print(num)
4 结果：
5 3

View Code

index()：找到元素对应的索引，列表中通过元素找索引只有index

1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']
2 num = my_list.index('quan')  #找到元素对应的索引，对列表进行通过元素找索引只有index()方法
3 print(num)
4 结果：
5 2

View Code

1 my_list = ['peng','li',"quan",'钟',[1,2,3],'钟','钟三','钟','钱']
2 num = my_list.index('钟')  #找到元素对应的索引，对列表进行通过元素找索引只有index()方法
3 print(num)
4 结果：
5 3
6 
7 即返回第一次找到元素的索引

View Code

sort()：正向排序

1 my_list = [1,5,3,8,9,4,5,6,2,7,4]
2 my_list.sort() #正向排序
3 print(my_list)
4 结果：
5 [1, 2, 3, 4, 4, 5, 5, 6, 7, 8, 9]

View Code

sort（reverse = True）：反向排序

1 my_list = [1,5,3,8,9,4,5,6,2,7,4]
2 my_list.sort(reverse=True) #反向排序
3 print(my_list)
4 结果：
5 [9, 8, 7, 6, 5, 5, 4, 4, 3, 2, 1]

View Code

reverse()：反转排序，即前后对应的元素对调

1 my_list = [1,5,3,8,9,4,5,6,2,7,4]
2 my_list.reverse()
3 print(my_list) #反转
4 
5 结果：
6 [4, 7, 2, 6, 5, 4, 9, 8, 3, 5, 1]

View Code

7、列表的嵌套

1 #列表的嵌套
2 list_nest = ['peng111',"abc",['quan',"zhang",23],"中国"]
3 list_nest[2][1] = list_nest[2][1].capitalize() #把首字符变大写
4 print(list_nest)
5 结果：
6 ['peng111', 'abc', ['quan', 'Zhang', 23], '中国']

View Code

6、元组（tuple）

元组是只读列表，可以读，元组的儿子不改写，但元组的儿子可能可以写

1 my_tuple = ('a','b','c',1,2,3,["peng",'qian'],"tuple")
2 my_tuple[6][1] = my_tuple[6][1].upper()
3 print(my_tuple)
4 
5 my_tuple[6].append("zhang")
6 print(my_tuple)
7 结果：
8 ('a', 'b', 'c', 1, 2, 3, ['peng', 'QIAN'], 'tuple')
9 ('a', 'b', 'c', 1, 2, 3, ['peng', 'QIAN', 'zhang'], 'tuple')

View Code

7、 range()用法

range的用法：顾头不顾尾，范围的大小变化方向不能与步长的方向相反，否则输出为空，即什么也不输出

 1 for i in range(10):
 2     print(i)
 3 
 4 结果：
 5 0
 6 1
 7 2
 8 3
 9 4
10 5
11 6
12 7
13 8
14 9

View Code

 1 for i in range(1,10):
 2     print(i)
 3 结果：
 4 1
 5 2
 6 3
 7 4
 8 5
 9 6
10 7
11 8
12 9

View Code

1 for i in range(1,10,2):
2     print(i)
3 
4 结果：
5 1
6 3
7 5
8 7
9 9

View Code

1 for i in range(1,10,-2):
2     print(i)
3 结果：
4 （为空，什么也没输出，因为范围的大小变化方向与步长方向相反）

View Code

1 for i in range(10,1,-2):
2     print(i)
3 结果：
4 10
5 8
6 6
7 4
8 2

View Code

1 for i in range(10,1,2):
2     print(i)
3 结果：
4 （为空，没有输出，因为范围的大小变化方向与步长方向相反）

View Code

8、字典

8.1 增

字典的增加就两种方式

第一种：直接按键来增加

 1 my_dic = {
 2     'name':['peng','quan'],
 3     'age':[{'num':20,'num2':30}],
 4     True:1,
 5     (1,2,3):"junfei",
 6     3:'B2'
 7 }
 8 
 9 my_dic['high'] = 175 #字典里面原来没有时候，就直接添加
10 print(my_dic)
11 my_dic['age'] = 25   #如果字典里面已经有了，那么就覆盖掉原来的
12 print(my_dic)
13 
14 结果：
15 {'name': ['peng', 'quan'], 'age': [{'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'high': 175}
16 {'name': ['peng', 'quan'], 'age': 25, True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'high': 175}

View Code

第二种：setdefault

1 my_dic.setdefault('weight')
2 print(my_dic)
3 my_dic.setdefault('name','li') #如果字典里面已经有相应的键值对，则不作任何改变，没有的话则添加
4 print(my_dic)
5 结果：
6 {'name': ['peng', 'quan'], 'age': [{'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'weight': None}
7 {'name': ['peng', 'quan'], 'age': [{'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2', 'weight': None}

View Code

8.2 删

第一种：按确定键来删除某一个键值

 1 my_dic = {
 2     'name':['peng','quan'],
 3     'age':[{'num':20,'num2':30}],
 4     True:1,
 5     (1,2,3):"junfei",
 6     3:'B2'
 7 }
 8 print(my_dic.pop('age'))          #有返回值，按键值去删除
 9 print(my_dic)
10 结果：
11 [{'num': 20, 'num2': 30}]
12 {'name': ['peng', 'quan'], True: 1, (1, 2, 3): 'junfei', 3: 'B2'}

View Code

第二种：不确定将被删除的键是否在字典中

 1 my_dic = {
 2     'name':['peng','quan'],
 3     'age':[{'num':20,'num2':30}],
 4     True:1,
 5     (1,2,3):"junfei",
 6     3:'B2'
 7 }
 8 
 9 print(my_dic.pop('zhong',None))   #这里的None是在不确定字典里面是否有我们想删的键值时候用，即如果字典有
10 #                                   #要删的键则删除，如果没有不至于会报错，即可设置返回值
11 print(my_dic)
12 
13 结果：
14 None
15 {'name': ['peng', 'quan'], 'age': [{'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei', 3: 'B2'}

View Code

第三种：直接删除最后一个键值

 1 my_dic = {
 2     'name':['peng','quan'],
 3     'age':[{'num':20,'num2':30}],
 4     True:1,
 5     (1,2,3):"junfei",
 6     3:'B2'
 7 }
 8 print(my_dic.popitem() ) #从3.6版本开始，就是直接删除最后一个，返回值为键值及Value组成的元组
 9 print(my_dic)
10 
11 结果：
12 (3, 'B2')
13 {'name': ['peng', 'quan'], 'age': [{'num': 20, 'num2': 30}], True: 1, (1, 2, 3): 'junfei'}

View Code

第四种：清空一个字典

1 my_dic = {
2     'name':['peng','quan'],
3     'age':[{'num':20,'num2':30}],
4     True:1,
5     (1,2,3):"junfei",
6     3:'B2'
7 }
8 结果：
9                为空，没有输出

View Code

第五钟：删除一个字典，删除以后，那个字典就不存在，如果还调勇print（）函数则报错

 1 my_dic = {
 2     'name':['peng','quan'],
 3     'age':[{'num':20,'num2':30}],
 4     True:1,
 5     (1,2,3):"junfei",
 6     3:'B2'
 7 }
 8 del my_dic
 9 print(my_dic)
10 
11 结果：
12 NameError: name 'my_dic' is not defined

View Code

8.3 改

第一种：覆盖

 1 my_dic = {
 2     'name':['peng','quan'],
 3     'age':[{'num':20,'num2':30}],
 4     True:1,
 5     (1,2,3):"junfei",
 6     3:'B2'
 7 }
 8 my_dic['age'] = 22  #改的第一种方式就是覆盖
 9 print(my_dic)
10 
11 结果：
12 {'name': ['peng', 'quan'], 'age': 22, True: 1, (1, 2, 3): 'junfei', 3: 'B2'}

View Code

第二种：一个字典更新到另一个字典方式

 1 my_dic2 = {"name":'peng','age':25,'hight':175}
 2 my_dic3 = {'name':'quan','sex':'fmale'}
 3 
 4 my_dic3.update(my_dic2)  #把my_dic2更新到my_dic3中，有键值的就覆盖，没有的就添加
 5 print(my_dic2)
 6 print(my_dic3)
 7 
 8 结果：
 9 {'name': 'peng', 'age': 25, 'hight': 175}
10 {'name': 'peng', 'sex': 'fmale', 'age': 25, 'hight': 175}

View Code

8.4 查

第一种：查键

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 print(my_dic2.keys(),type(my_dic2.keys()))  #以列表形式保存键值
3 
4 结果：
5 dict_keys(['name', 'age', 'hight']) <class 'dict_keys'>

View Code

第二种：查值

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 
3 print(my_dic2.values(),type(my_dic2.values())) #以列表形式保存值
4 
5 结果：
6 dict_values(['peng', 25, 175]) <class 'dict_values'>

View Code

第三种：查键值对

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 print(my_dic2.items()) #以列表形式保存键值对
3 
4 结果：
5 dict_items([('name', 'peng'), ('age', 25), ('hight', 175)])

View Code

第四种：直接按键查找，查得到则返回键对应的值，查不到则报错

 1 my_dic2 = {"name":'peng','age':25,'hight':175}
 2 print(my_dic2['age'])  #得到键对应的值
 3 print(my_dic2['age3']) #如果没有这个键的话，就报错
 4 
 5 结果：
 6 25
 7 Traceback (most recent call last):
 8   File "E:/Python Project/05/Day5/dict.py", line 63, in <module>
 9     print(my_dic2['age3']) #如果没有这个键的话，就报错
10 KeyError: 'age3'

View Code

第五种：get方法，查得到则返回键对应的值，查不到则返回None，或者返回自定义的值

1 print(my_dic2.get('hight'))
2 print(my_dic2.get('age4')) #get的方法是查找这个键是否有，如果没有则返回None
3 print(my_dic2.get('age4',"没有这个键")) #为了避免没有键时候返回None，我们加了“没有这个键”这个自定义返回值，辅助理解
4 
5 结果：
6 175
7 None
8 没有这个键

View Code

8.5 字典在for循环引用中的不同

什么都不写，默认打印的是键

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 for i in my_dic2:
3     print(i)  #什么都不写，默认打印的是键
4 
5 结果：
6 name
7 age
8 hight

View Code

打印出键

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 
3 for i in my_dic2.keys(): #打印出键
4     print(i)
5 结果：
6 name
7 age
8 hight

View Code

打印出值

my_dic2 = {"name":'peng','age':25,'hight':175}

for i in my_dic2.values(): #打印出值
    print(i)

结果：
peng
25
175

View Code

打印出元组形式的键值对

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 for i in my_dic2.items():  #打印出键值对的元组，用括号包括
3     print(i) #每次循环，i是元组
4 
5 结果：
6 ('name', 'peng')
7 ('age', 25)
8 ('hight', 175)

View Code

直接打印出键及值，没有元组形式的那个括号

1 my_dic2 = {"name":'peng','age':25,'hight':175}
2 for k,v in my_dic2.items():#直接打印出键值
3     print(k,v)
4 结果：
5 name peng
6 age 25
7 hight 175

View Code

8.6 字典的嵌套

1 my_dict = {
2     'name':['peng','quan','li','zhang'],
3     'chanpin':{'jiaoyan':10,
4                  "gongchen":4,
5                 "shengchan":8
6                 },
7     'age':25
8 }

直接改变值：

 1 my_dict = {
 2     'name':['peng','quan','li','zhang'],
 3     'chanpin':{'jiaoyan':10,
 4                  "gongchen":4,
 5                 "shengchan":8
 6                 },
 7     'age':25
 8 }
 9 my_dict['age'] = 22
10 print(my_dict)
11 结果：
12 {'name': ['peng', 'quan', 'li', 'zhang'], 'chanpin': {'jiaoyan': 10, 'gongchen': 4, 'shengchan': 8}, 'age': 22}

View Code

查找键对应的值

 1 my_dict = {
 2     'name':['peng','quan','li','zhang'],
 3     'chanpin':{'jiaoyan':10,
 4                  "gongchen":4,
 5                 "shengchan":8
 6                 },
 7     'age':25
 8 }
 9 
10 print(my_dict['chanpin'])
11 结果：
12 {'jiaoyan': 10, 'gongchen': 4, 'shengchan': 8}

View Code

在相应键的值增加元素

 1 my_dict = {
 2     'name':['peng','quan','li','zhang'],
 3     'chanpin':{'jiaoyan':10,
 4                  "gongchen":4,
 5                 "shengchan":8
 6                 },
 7     'age':25
 8 }
 9 my_dict["name"].append("liu")
10 my_dict["chanpin"]["ruanjian"] = 12
11 print(my_dict)
12 结果：
13 {'name': ['peng', 'quan', 'li', 'zhang', 'liu'], 'chanpin': {'jiaoyan': 10, 'gongchen': 4, 'shengchan': 8, 'ruanjian': 12}, 'age': 25}

View Code

9、集合

集合：可变的数据类型，它里面的元素必须是不可变的数据类型，且无序，不重复
假如要把列表里面的元素去重，那么直接把列表转变为集合即可。
增、删、查，没有改

set2 = set({1,2,3,4})
print(set2)set3 = {1,2,3,[4,5],{'name':'peng','age':20}} #集合里面不能是可变数据类型list、dict

9.1 增

第一种add

1 set2 = {'peng','quan','li','zhang'}
2 # #第一种add
3 set2.add('lan')
4 print(set2)
5 
6 结果：
7 {'li', 'quan', 'zhang', 'peng', 'lan'}

View Code

第二种updata

1 set2 = {'peng','quan','li','zhang'}
2 #第二种updata
3 set2.update('zhu') #无序地把每个元素增加到集合中
4 print(set2)
5 结果：
6 {'z', 'h', 'zhang', 'li', 'quan', 'u', 'peng'}

View Code

9.2 删

pop()随机删除,返回被删除的元素

1 set2 = {'peng','quan','li','zhang'}
2 return2 = set2.pop()
3 print(return2)
4 print(set2)
5 结果：
6 li
7 {'peng', 'quan', 'zhang'}

View Code

remove（），按元素去删,有则删，无则报错

1 set2 = {'peng','quan','li','zhang'}
2 set2.remove('peng')
3 print(set2)
4 结果：
5 {'quan', 'zhang', 'li'}

View Code

clear()清空集合

1 set2 = {'peng','quan','li','zhang'}
2 set2.clear()
3 print(set2)
4 结果：
5 set()
6 set()表示空集合，是为了区分空字典set{}

View Code

del 删除整个集合

1 set2 = {'peng','quan','li','zhang'}
2 del set2
3 print(set2)
4 结果：
5 Traceback (most recent call last):
6   File "E:/Python Project/05/Day7/集合&深浅Copy.py", line 41, in <module>
7     print(set2)
8 NameError: name 'set2' is not defined

View Code

9.3 查

1 set2 = {'peng','quan','li','zhang'}
2 for i in set2:
3     print(i)
4 结果：
5 peng
6 quan
7 li
8 zhang
9 这个结果每次是不一样的

View Code

9.4 交集

1 set3 = {2,3,4,5,6}
2 set4 = {5,6,7,8,9,10}
3 set5 = set3 & set4
4 print(set5)
5 print(set3 & set4)
6 print(set3.intersection(set4))

View Code

结果：

1 {5, 6}
2 {5, 6}
3 {5, 6}

View Code

9.5并集

1 set3 = {2,3,4,5,6}
2 set4 = {5,6,7,8,9,10}
3 print(set3.union(set4))

View Code

结果：

1 {2, 3, 4, 5, 6, 7, 8, 9, 10}

View Code

9.6反交集

1 set3 = {2,3,4,5,6}
2 set4 = {5,6,7,8,9,10}
3 print(set3 ^ set4)
4 print(set3.symmetric_difference(set4))

View Code

结果：

1 {2, 3, 4, 7, 8, 9, 10}
2 {2, 3, 4, 7, 8, 9, 10}

View Code

9.7 差集

1 set3 = {2,3,4,5,6}
2 set4 = {5,6,7,8,9,10}
3 print(set3 - set4) #就是得到set3独有的元素

View Code

结果：

1 {2, 3, 4}

View Code

9.8 子集

1 set5 = {1,2,3}
2 set6 = {1,2,3,4,5}
3 print(set5 < set6) #需要set5里的元素全部包含在set6中
4 print(set5.issubset(set6)) #说明set5是set6的子集

View Code

结果：

1 True
2 True

View Code

9.9 超集

1 set5 = {1,2,3}
2 set6 = {1,2,3,4,5}
3 print(set6 > set5) #说明set6是set5的超集
4 print(set6.issuperset(set5)) #说明set6是set5的超集

View Code

结果：

1 True
2 True

View Code

9.10冻住

frozenet(),把set变为不可变数据类型（set本身是可变数据类型）

1 s2  = {1,2,3,'abc'}
2 s2 = frozenset(s2)
3 print(s2,type(s2))

View Code

结果：

1 frozenset({1, 2, 3, 'abc'}) <class 'frozenset'>

View Code

10 深浅Copy

10.1 浅copy

在内存中重新创建了一个空间存放一个新列表，新列表中的元素与原列表中的元素是公用的。
例1：

1 l2 = [1,2,3]
2 l3 = l2.copy()
3 print(l2,l3)
4 print(id(l2),id(l3))
5 l3.append(4)
6 print(l2,l3)

View Code

结果：

1 [1, 2, 3] [1, 2, 3]
2 37365960 37217224
3 [1, 2, 3] [1, 2, 3, 4]

View Code

例2：

1 l2 = [1,2,'peng',[4,5,6],7]
2 l3 = l2.copy()
3 print(l2,id(l2))
4 print(l3,id(l3))
5 print(id(l2[-1]),id(l3[-1]))
6 print(id(l2[-2]),id(l3[-2]))

View Code

结果：

1 [1, 2, 'peng', [4, 5, 6], 7] 43574216
2 [1, 2, 'peng', [4, 5, 6], 7] 43724552
3 1540514144 1540514144
4 43722952 43722952

View Code

10.2 深copy：deepcopy

新列表是在内存中新创建的，新列表中可变数据类型元素是新创建的，不可变数据类型元素是公用的
例1：

 1 import copy
 2 l2 = [1, 2, 'peng', [4, 5, 6], 7]
 3 l3 = copy.deepcopy(l2)
 4 print(l2,id(l2))
 5 print(l3,id(l3))
 6 print(id(l2[-1]),id(l3[-1]))
 7 print(id(l2[-2]),id(l3[-2]))
 8 print(id(l2[-3]),id(l3[-3]))
 9 print(id(l2[-4]),id(l3[-4]))
10 print(id(l2[-5]),id(l3[-5]))

View Code

结果：

1 [1, 2, 'peng', [4, 5, 6], 7] 44051208
2 [1, 2, 'peng', [4, 5, 6], 7] 44050504
3 1540514144 1540514144
4 44052232 44078408
5 35109440 35109440
6 1540513984 1540513984
7 1540513952 1540513952

View Code

posted @ 2019-03-13 22:37 xiaofeiAI 阅读(318) 评论(0) 编辑收藏举报

刷新页面返回顶部

小飞的

数据类型

0、基本数据类型：

0.1、 int类型

1、字符串类型（str）

2、格式化输出

2.1 %s就是代表字符串占位符，%d是数字占位符，如果是%d则表示必须输入数字。另外如果想表达50%类似这样带%输出的情况，那么在%后面再加一个%，表示转义

2.2 format的三种用法格式化输出

3、字符串的索引及切片

3.1 字符串的前后删除某个字符 strip()、lstrip()、rstrip()

3.2 计算字符串中指定字符的个数 count()

3.3 把字符串按字符串中某个字符进行分割，一分为二地分割为列表 split()

4、布尔值

5、列表(list)

6、元组（tuple）

7、 range()用法

8、字典

8.1 增

8.2 删

8.3 改

8.4 查

8.5 字典在for循环引用中的不同

8.6 字典的嵌套

9、集合

9.1 增

9.2 删

9.3 查

9.4 交集

9.5并集

9.6反交集

9.7 差集

9.8 子集

9.9 超集

9.10冻住

10 深浅Copy

10.1 浅copy

10.2 深copy：deepcopy

公告

小飞的

数据类型

0、基本数据类型：

0.1、 int类型

1、字符串类型（str）

2、格式化输出

2.1 %s就是代表字符串占位符，%d是数字占位符，如果是%d则表示必须输入数字。另外如果想表达50%类似这样带%输出的情况，那么在%后面再加一个%，表示转义

2.2 format的三种用法 格式化输出

3、字符串的索引及切片

3.1 字符串的前后删除某个字符 strip()、lstrip()、rstrip()

3.2 计算字符串中指定字符的个数 count()

3.3 把字符串按字符串中某个字符进行分割，一分为二地分割为列表 split()

4、布尔值

5、列表(list)

6、元组（tuple）

7、 range()用法

8、字典

8.1 增

8.2 删

8.3 改

8.4 查

8.5 字典在for循环引用中的不同

8.6 字典的嵌套

9、集合

9.1 增

9.2 删

9.3 查

9.4 交集

9.5并集

9.6反交集

9.7 差集

9.8 子集

9.9 超集

9.10冻住

10 深浅Copy

10.1 浅copy

10.2 深copy：deepcopy

公告

2.2 format的三种用法格式化输出