Python基础
对于Python,一切事物都是对象，对象基于类创建
所以，以下这些值都时对象："zhurui"、22、['北京','上海','深圳']，并且是根据不同的类生成的对象。
一、基本数据类型
数字(int)
如：21、45、56
每一个整数都具备如下功能：
1 - int 2 将字符串转换为数字 3 例子： 4 a = "123" 5 print(type(a),a) 6 输出结果： 7 >>> a = "123" 8 >>> print(type(a),a) 9 <class 'str'> 123 10 11 b = int(a) 12 print(type(b),b) 13 14 输出结果： 15 >>> b = int(a) 16 >>> print(type(b),b) 17 <class 'int'> 123 18 19 num = "0022" 20 v = int(num, base=16) 21 print(v) 22 23 输出结果： 24 >>> num = "0022" 25 >>> v = int(num, base=16) 26 >>> print(v) 27 34 28 29 - bit_length 30 #当前数字的二进制，至少用n位表示 31 age = 22 32 v = age.bit_length() 33 print(v) 34 35 输出结果： 36 >>> age = 22 37 >>> v = age.bit_length() 38 >>> print(v) 39 5
字符串(str)
1、name.capitalize() #首字母大写
例子：
>>> test = "zhUrui" >>> v = test.capitalize() >>> print(v) Zhurui
2、name.casefold() #所有变小写，casefold更牛逼，很多未知的对相应变小写
例子：
>>> test = "zhUrui" >>> v1 = test.casefold() >>> print(v1) zhurui >>> v2 = test.lower() >>> print(v2) zhurui
3、name.center() #设置宽度，并将内容居中
name.ljust() #设置宽度，变量向左，其他部分用所定义的填充符 填充
name.rjust() #设置宽度，变量向右，其他部分用所定义的填充符 填充
name.zfill() #设置宽度，默认变量向右，其他部分用zfill方法特定的填充符"000" 填充
>>> test = "zhurui" >>> v = test.center(20,"中") >>> print(v) 中中中中中中中zhurui中中中中中中中 解释： # 20 代指总长度 # * 空白未知填充，一个字符，可有可无 输出结果： 中中中中中中中zhurui中中中中中中中 ########################################## >>> test = "zhurui" >>> v = test.ljust(20,"*") #ljust 变量靠左，其他部分用*填充 >>> print(v) zhurui************** ################################## >>> test = "zhurui" >>> v = test.rjust(20,"*") #rjust 变量靠右，其他部分用*填充 >>> print(v) **************zhurui
>>> test = "zhurui" >>> v = test.zfill(20) ##zfill只能用于000填充 >>> print(v) 00000000000000zhurui
4、name.count() #去字符串中寻找，寻找子序列的出现次数
>>> test = "Zhuruizhuruiru" >>> v = test.count('ru') >>> print(v) 3 >>> v = test.count('z') >>> print(v) 1 ######################################### >>> test = "Zhuruizhuruiru" >>> v = test.count('ru', 5, 6) >>> print(v) 0
5、name.encode() #将字符串编码成bytes格式
6、name.decode()
7、name.endswith("ui") #判断字符串是否以ui结尾
name.startswith('ui') #判断字符串是否以ui开始
>>> test = "zhurui" >>> v = test.endswith('ui') >>> print(v) True >>> v = test.startswith('ui') >>> print(v) False
8、"Zhu Rui".expandtabs(10) #输出‘Zhu Rui’, 将 转换为多长的空格
>>> test = "Zhu Rui" >>> v = test.expandtabs(10) >>> print(v) Zhu Rui ################################ test = "username password email zhurui 123456 24731701@qq.com zhurui 123456 24731701@qq.com zhurui 123456 24731701@qq.com" v = test.expandtabs(20) print(v) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day1/logging.py username password email zhurui 123456 24731701@qq.com zhurui 123456 24731701@qq.com zhurui 123456 24731701@qq.com
9、name.find(A) #从开始往后找，找到第一个之后，获取其位置即索引，找不到返回-1
## > 或 >=
# 未找到 -1
>>> test = "williamwilliam" >>> v = test.find('am') >>> print(v) 5 >>> v = test.find('t') #找变量中的"t"字符， >>> print(v) -1 ##没有找到，返回负一
10、name.index('a') #找不到，报错
>>> test = "williamwilliam" >>> v = test.index('a') >>> print(v) 5 >>> v = test.index('8') ##找字符串中是否 Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: substring not found
11、name.format() #格式化，将一个字符串中的占位符替换为指定的值
>>> test = 'i am {name}, age {a}' >>> print(test) i am {name}, age {a} >>> v = test.format(name='william',a=22) >>> print(v) i am william, age 22
>>> test = 'i am {0},age {1}' >>> print(test) i am {0},age {1} >>> v = test.format('william', 22) >>> print(v) i am william,age 22
12、name.format_map() #格式化， 传入的值{"name": 'william', "a": 22}
>>> test = 'i am {name}, age {a}' >>> v1 = test.format(name='zhurui',a=22) >>> v2 = test.format_map({"name":'zhurui', "a": 19}) >>> print(v1) i am zhurui, age 22 >>> print(v2) i am zhurui, age 19
13、name.isalnum() #字符串中是否只包含 字母和数字
>>> test = "234" >>> v = test.isalnum() >>> print(v) True
14、name.isalpha() #是否是字母，汉字
>>> test = "asfdge242" >>> v = test.isalpha() >>> print(v) False >>> test = "威廉" >>> v = test.isalpha() >>> print(v) True
15、判断输入的是否是数字
>>> test = "二" # 1 ， ② >>> v1 = test.isdecimal ##判断十进制小数 >>> v2 = test.isdigit() >>> v3 = test.isnumeric() ##判断汉语的数字，比如 "二" >>> print(v1,v2,v3) <built-in method isdecimal of str object at 0x00000201FE440AB0> False True
16、name.isprintable() #判断是否存在不可显示的字符
制表符
换行
>>> test = "qepoetewt fdfde" >>> v = test.isprintable() >>> print(v) False >>> test = "qepoetewtfdfde" >>> v = test.isprintable() >>> print(v) True
17、name.isspace() #判断是否全部是空格
>>> test = "" >>> v = test.isspace() >>> print(v) False >>> test = " " >>> v = test.isspace() >>> print(v) True
18、name.istitle() #判断是否是标题，其中必须首字母大写
>>> test = "Return True if all cased characters in S are uppercase" >>> v1 = test.istitle() >>> print(v1) False >>> v2 = test.title() #将字符串首字母大写 >>> print(v2) Return True If All Cased Characters In S Are Uppercase >>> v3= v2.istitle() >>> print(v3) True
19、***** name.join() #将字符串中的每一个元素按照指定分隔符进行拼接（五星重点参数）
>>> test = "出任CEO迎娶白富美" >>> print(test) 出任CEO迎娶白富美 >>> v = '_'.join(test) >>> print(v) 出_任_C_E_O_迎_娶_白_富_美 >>>
20、name.islower() #判断是否全部是大小写 和 转换为大小写
>>> test = "William" >>> v1 =test.islower() #判断是否全都是小写 >>> v2 = test.lower() #将变量转换为小写 >>> print(v1, v2) False william >>> ################################### >>> test = "William" >>> v1 =test.isupper() #判断是否全都是大写 >>> v2 = test.upper() #将变量转换为大写 >>> print(v1, v2) False WILLIAM
21、移除指定字符串，优先最多匹配
>>> test = 'xa' >>> v1 =test.isupper() >>> v = test.lstrip("xa") >>> print(v) >>> v = test.rstrip("92exxxexxa") >>> print(v) >>> v = test.strip("xa") >>> print(v) ################################### # test.lstrip() # test.rstrip() # test.strip() # 去除左右空白 # v = test.lstrip() # v = test.rstrip() # v = test.strip() # print(v) # print(test) # 去除 # v = test.lstrip() # v = test.rstrip() # v = test.strip() # print(v)
22、对应关系替换
>>> test = "aeiou" >>> test1 = "12345" >>> v = "asidufkasd;fiuadkf;adfkjalsdjf" >>> m = str.maketrans("aeiou", "12345") >>> new_v = v.translate(m) >>> print(new_v) 1s3d5fk1sd;f351dkf;1dfkj1lsdjf
23、name.partition() #分割为三部分
>>> test = "testegerwerwegwewe" >>> v = test.partition('s') >>> print(v) ('te', 's', 'tegerwerwegwewe') >>> v = test.rpartition('s') >>> print(v) ('te', 's', 'tegerwerwegwewe') >>>
24、name.split() #分格为指定个数
>>> test = "sagesgegessress" >>> v = test.split('s',2) >>> print(v) ['', 'age', 'gegessress'] >>>
25、分割， 只能根据，true, false：是否保留换行
>>> test = "fwerwerdffrweqnndasfqfnaqewrwe" >>> v = test.splitlines(False) >>> print(v) ['fwerwerdf', 'rweqnndasfq', 'naqewrwe']
26、以xxx开头，以xx结尾
>>> test = "backend 1.2.3.4" >>> v = test.startswith('a') >>> print(v) False >>> test.endswith('a') False
27、name.swapcase() #大小写转换
>>> test = "WiiLiAm" >>> v = test.swapcase() >>> print(v) wIIlIaM
28、name.isidentifier() #字母，数字，下划线 ：标识符 def class
>>> a = "def" >>> v = a.isidentifier() >>> print(v) True
29、name.replace() #将指定字符串替换为指定字符串，替换功能相当于sed
>>> test = "williamwilliamwilliam" >>> v = test.replace("am", "bbb") >>> print(v) willibbbwillibbbwillibbb >>> v = test.replace("am", "bbb",2) >>> print(v) willibbbwillibbbwilliam >>>
字符串总结
################7个基本魔法################# join # '_'.join("asdfdfsdsf") split find strip upper lower replace(相当于sed替换功能) ################4个灰魔法################# 一、for循环 格式： for 变量名 in 字符串: 变量名 break continue 例子： test = "好看的妹子有种冲我来" for item in test: print(item) break 输出结果为： 好 例子2： test = "好看的妹子有种冲我来" index = 0 while index < len(test): v = test[index] print(v) index += 1 print('============') 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day12/index1.py 好 看 的 妹 子 有 种 冲 我 来 ============ 例子3：(比较break跟continue的区别) test = "好看的妹子有种冲我来" for item in test: print(item) break 输出结果为： 好 for item in test: print(item) continue 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day12/index1.py 好 看 的 妹 子 有 种 冲 我 来 二、索引，下标，获取字符串中的某一个字符 test = "好看的妹子有种冲我来" v = test[3] print(v) 输出结果为： 妹 三、切片 v = test[0:1] #标识大于等于0，小于1(0<= <1) print(v) 输出结果为： 好 四、获取长度 Python3: len获取当前字符串中由几个字符组成 v = len(test) print(v) 输出结果为： 10 注意： len("asdf") for循环 索引 切片
五、获取连续或不连续的数字 Python2中直接创建在内容中 Python3中只有for循环时，才一个一个创建 例子： r1 = range(10) print(r1) 输出结果为： 10 range(0, 10) 执行for循环时： 才会一个一个创建打印 r2 = range(1,10) r3 = range(1,10,2) 帮助创建连续的数字，通过设置步长来指定不连续 v = range(0, 100, 5) #括号中的5代表步长 for item in v: print(item)
练习题：根据用户输入的值，输出每一个字符以及当前字符所在的索引位置
将文字 对应的索引打印出来:
方法1：
test = input(">>>")
print(test) # test = qwe test[0] test[1]
l = len(test) # l = 3
print(l)
r = range(0,l) # 0,3
for item in r:
print(item, test[item]) # 0 q,1 w,2 e
方法2：
test = input('>>>')
for item in range(0, len(test)):
print(item, test[item])
##################### 1个深灰魔法 ######################
字符串一旦创建，不可修改
一旦修改或者拼接，都会造成重新生成字符串
name = "william"
age = "22"
info = name + age
print(info)
列表(list)
如：["william",'zhurui']、["ray","william"]
#################深灰魔法#####################
1、列表格式
# 中括号括起来 # ， 逗号分隔每个元素 # 列表中的元素可以是 数字，字符串，列表，布尔值.. 所有的都能放进去 # “集合”， 内部放置任何东西
2、列表中可以嵌套任何类型
# 列表中的元素可以是 数字，字符串，列表，布尔值.. 所有的都能放进去 # “集合”， 内部放置任何东西
3、索引取值
# list # 类，列表 li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] # 通过list类创建的对象，li >>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> print(li[2]) 9 >>> print(li[4][0]) 朱锐
4、切片，切片结果也是列表
>>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> print(li[3:-1]) ['age', ['朱锐', ['19', 10], '朱'], 'william']
5、列表是可迭代的所以for循环、while循环都通用
>>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> for item in li: ... print(item) ... 1 12 9 age ['朱锐', ['19', 10], '朱'] william True >>>
####列表元素，可以被修改
6、通过索引的方式修改
>>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> li[0] = "zhurui" >>> print(li) ['zhurui', 12, 9, 'age', ['朱锐', ['19', 10], '朱'], 'william', True] >>> li[1] = [11,22,44] #将原来索引1所对应内存中的12，赋值一个新的列表[11,22,44] >>> print(li) ['zhurui', [11, 22, 44], 9, 'age', ['朱锐', ['19', 10], '朱'], 'william', True] >>>
7、通过切片的方式修改列表中的元素
#修改中还有一个特殊的方法del >>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> del li[1] >>> print(li) [1, 9, 'age', ['朱锐', ['19', 10], '朱'], 'william', True] >>> #通过切片的方式删除 >>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> del li[2:6] #2<= <6 >>> print(li) [1, 12, True] >>> #通过切片的方式修改 >>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> li[1:3] = [120,90] >>> print(li) [1, 120, 90, 'age', ['朱锐', ['19', 10], '朱'], 'william', True] >>>
8、in 操作
>>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> v1 = "朱锐" in li >>> print(v1) False >>> v2 = "age" in li >>> print(v2) True >>> v3 = "william" in li >>> print(v3) True
####列表中的元素
9、操作
>>> li = [1, 12, 9, "age", ["朱锐", ["19", 10], "朱"], "william", True] >>> li[4][1][0] '19'
10、转换
>>> s = 123 >>> a = "123" >>> int(a) #将字符串转换为数字 123 >>> a = 123 >>> str(a) #将数字转换为字符串 '123' ##字符串转换为列表 >>> li = list("asdfgeqrererdfgaf") #字符串转换为列表实质是内部使用了for循环 >>> print(li) ['a', 's', 'd', 'f', 'g', 'e', 'q', 'r', 'e', 'r', 'e', 'r', 'd', 'f', 'g', 'a', 'f'] >>> >>> s = "erewsfsasdfe" >>> new_li = list(s) >>> print(new_li) ['e', 'r', 'e', 'w', 's', 'f', 's', 'a', 's', 'd', 'f', 'e'] ##列表转换为字符串，有两种处理方法： 1、需要自己写for循环一个一个处理： >>> li = [12,14,146,"343","william"] >>> r = str(li) >>> print(r) [12, 14, 146, '343', 'william'] #当直接将列表使用str转换为字符串时，其他的都无变化，只是双引号变为单引号 >>> s = "" #定义一个空的字符串 >>> for i in li: #循环列表 ... s += str(i) #使用for循环将列表中的元素转换为字符串与空字符串相加，得到新的变量s ... >>> print(s) 1214146343william 2、直接使用字符串join方法：只仅仅适用于列表中的元素只有字符串 >>> li = ["4324","william"] >>> v = "".join(li) >>> print(v) 4324william ##补充：字符串创建后，不可修改 >>> v = "william" >>> v = v.replace('w','am') #使用字符串的方法，将w替换为am >>> print(v) amilliam >>> li = [11,232,434,45] >>> li[0] 11 >>> li[0] = 999 #重新赋值标识为的值 >>> print(li) [999, 232, 434, 45] ##字符串创建后，如果修改会报错 >>> s = "william" >>> s[0] 'w' >>> s[0] = "E" Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment
##############灰魔法： list类中提供的方法#####################
1、原来值最后追加，不需要再定义变量
#参数 # 对象.方法(..) #li对象调用append方法 >>> li = [13,15,45,56,78] >>> li.append(5) >>> li.append("william") >>> li.append([134,34232]) >>> print(li) [13, 15, 45, 56, 78, 5, 'william', [134, 34232]] >>>
2、清空列表
>>> print(li) [13, 15, 45, 56, 78, 5, 'william', [134, 34232]] >>> v = list(li) >>> print(v) [13, 15, 45, 56, 78, 5, 'william', [134, 34232]] >>> v.clear() >>> print(v) [] #列表为空
3、拷贝，浅拷贝，需要新值接收
>>> li = [12,13,14,15,16] >>> v = li.copy() >>> print(v) [12, 13, 14, 15, 16] >>>
4、计算元素出现的次数
>>> li = [12,13,14,13,16] >>> v = li.count(13) >>> print(v) 2
5、扩展原列表，参数：可迭代对象，内部执行for循环
>>> li = [11,22,33,44,22,45] >>> li.append([798, "朱锐"]) >>> print(li) [11, 22, 33, 44, 22, 45, [798, '朱锐']] >>> >>> li.extend([798,"朱锐"]) #extend的实质就是下面执行的for循环中append追加 >>> print(li) [11, 22, 33, 44, 22, 45, [798, '朱锐'], 798, '朱锐'] >>> for i in [798, "朱锐"]: ... li.append(i) ... >>> print(li) [11, 22, 33, 44, 22, 45, [798, '朱锐'], 798, '朱锐', 798, '朱锐']
6、根据值获取当前值索引位置(左边优先)
>>> li = [12,14,15,16,18,45] >>> v = li.index(15) >>> print(v) 2
7、在指定索引位置插入元素
>>> li = [12,14,15,16,18,45] >>> li.insert(0,99) >>> print(li) [99, 12, 14, 15, 16, 18, 45]
8、删除某个值(1.指定索引；2.默认最后一个)，并获取删除的值
>>> li = [12,14,15,16,18,45] >>> v = li.pop() >>> print(li) [12, 14, 15, 16, 18] >>> print(v) 45 >>> >>> li = [12,14,15,16,18,45] >>> v = li.pop(3) #跟索引的值，删除索引的值 >>> print(li) [12, 14, 15, 18, 45] >>> print(v) 16
9、删除列表中的指定值，左边优先
>>> li = [12,14,15,16,18,45] >>> li.remove(14) >>> print(li) [12, 15, 16, 18, 45]
10、将当前列表进行翻转
>>> li = [12,14,15,16,18,45] >>> li.reverse() >>> print(li) [45, 18, 16, 15, 14, 12] >>>
11、列表的排序
>>> li = [13,34,23,12,45,67] >>> li.sort() >>> print(li) [12, 13, 23, 34, 45, 67] >>> li.sort(reverse=True) >>> print(li) [67, 45, 34, 23, 13, 12]
后面更新：
#cmp
#key
#sorted
总结：
################################################ # 列表，有序，元素可以被修改 # 列表 # list # li = [111.345,345,456] ################################################ # 元祖，元素不可被修改，不能被增加或者删除 # tuple # tu = (11,22,33,44,) # tu.count(22) 获取指定元素在元祖中出现的次数 # tu.index(22)
元祖(tuple)
################# 深灰魔法 ##################
1、书写格式
# tu = (123,"william",(11,22),[(33,34)],True,34,56,) # 一般写元祖的时候，推荐在最后加，"逗号"； # 元素不可被修改，不能被增加或者删除
2、索引
>>> tu = (123,"william",(11,22),[(33,34)],True,34,56,) >>> v = tu[1] >>> print(v) william
3、切片
>>> tu = (123,"william",(11,22),[(33,34)],True,34,56,) >>> r = tu[0:2] >>> print(r) (123, 'william')
4、可以被for循环，可迭代对象
>>> tu = (123,"william",(11,22),[(33,34)],True,34,56,) >>> for item in tu: ... print(item) ... 123 william (11, 22) [(33, 34)] True 34 56
5、转换
>>> s = "asdfgher" >>> li = ["asdfg","asgewerf"] >>> tu = ("asdf","asfdf") >>> v = tuple(s) #字符串转换为元祖 >>> print(v) ('a', 's', 'd', 'f', 'g', 'h', 'e', 'r') >>> v = tuple(li) #列表转换为元祖 >>> print(v) ('asdfg', 'asgewerf') >>> v = "_".join(tu) #使用分隔符，将元祖分开 >>> print(v) asdf_asfdf >>> li = ["asdf","asdfdghsd"] >>> li.extend((11,22,33)) #列表后面追加元祖，效果就是将元祖的特征小括号去掉，直接将元素追加到后面 >>> print(li) ['asdf', 'asdfdghsd', 11, 22, 33]
6、元祖的一级元素不可修改/删除/增加
>>> tu = (111,"william",(11,22),[(33,44)],True,33,44,) >>> v = tu[3][0][0] #根据索引取值 >>> print(v) 33 >>> v = tu[3] >>> print(v) [(33, 44)] >>> tu[3][0] = 789 #根据索引间接修改值 >>> print(tu) (111, 'william', (11, 22), [789], True, 33, 44) >>>
字典(dict)
字典一种 key - value 的数据类型，使用就像我们上学用的字典，通过笔画、字母来查对应页的详细内容。
1、基本结构：
#字典 #dict dit = { "k1":"v1" #键值对 "k2":"v2" }
字典的特性：
● dict是无序的
● key必须是唯一的，所以天生去重
2、字典的value可以是任何值
>>> info = { ... "k1": 18, ... "k2": True, ... "k3": [ ... 11, ... [], ... (), ... 22, ... 33,yy ... { ... 'kk1': 'vv1', ... 'kk2': 'vv2', ... 'kk3': (11,22), ... } ... ], ... "k4": (11,22,33,44) ... } >>> print(info) {'k1': 18, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44), 'k2': True} >>>
3、布尔值(1,0)、列表、字典不能作为字典的key
>>> info ={ ... 1: 'asdf', ... "k1": 'asdf', ... True: "123", ... # [11,22]: 123 ... (11,22): 123, ... # {'k1':'v1'}: 123 ... ... } >>> print(info) {'k1': 'asdf', 1: '123', (11, 22): 123} >>> info ={ ... 1: 'asdf', ... "k1": 'asdf', ... True: "123", ... [11,22]: 123 #列表不能作为字典的key,否则会报错 ... # {'k1':'v1'}: 123 ... ... } Traceback (most recent call last): File "<stdin>", line 5, in <module> TypeError: unhashable type: 'list' >>> info ={ ... 1: 'asdf', ... "k1": 'asdf', ... True: "123", ... #[11,22]: 123 ... {'k1':'v1'}: 123 #字典不能作为字典的key，否则会报错 ... ... } Traceback (most recent call last): File "<stdin>", line 6, in <module> TypeError: unhashable type: 'dict' >>>
4、字典无序
>>> info = { ... "k1": 18, ... "k2": True, ... "k3": [ ... 11, ... [], ... (), ... 22, ... 33, ... { ... 'kk1': 'vv1', ... 'kk2': 'vv2', ... 'kk3': (11,22), ... } ... ], ... "k4": (11,22,33,44) ... } >>> print(info) {'k1': 18, 'k4': (11, 22, 33, 44), 'k2': True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]} >>>
5、索引方式找到指点元素
>>> info = { ... "k1": 18, ... 2: True, ... "k3": [ ... 11, ... [], ... (), ... 22, ... 33, ... { ... 'kk1': 'vv1', ... 'kk2': 'vv2', ... 'kk3': (11,22), ... } ... ], ... "k4": (11,22,33,44) ... } 输出结果： >>> v = info['k1'] >>> print(v) 18 >>> v = info[2] >>> print(v) True >>> v = info['k3'][5]['kk3'][0] >>> print(v) 11
6、字典支持del删除
>>> info = { ... "k1": 18, ... 2: True, ... "k3": [ ... 11, ... [], ... (), ... 22, ... 33, ... { ... 'kk1': 'vv1', ... 'kk2': 'vv2', ... 'kk3': (11,22), ... } ... ], ... "k4": (11,22,33,44) ... } >>> del info['k1'] >>> del info['k3'][5]['kk1'] >>> print(info) {'k4': (11, 22, 33, 44), 2: True, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}]}
7、for循环
>>> info = { ... "k1": 18, ... 2: True, ... "k3": [ ... 11, ... [], ... (), ... 22, ... 33, ... { ... 'kk1': 'vv1', ... 'kk2': 'vv2', ... 'kk3': (11,22), ... } ... ], ... "k4": (11,22,33,44) ... } >>> for item in info: ... print(item) ... k1 k4 2 k3 >>> for item in info.keys(): ... print(item) ... k1 k4 2 k3 >>> for item in info.values(): ... print(item) ... 18 (11, 22, 33, 44) True [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] >>> ##以下两种方法等价于 >>> for item in info.keys(): ... print(item,info[item]) ... k1 18 k4 (11, 22, 33, 44) 2 True k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] >>> >>> for k,v in info.items(): #会把dict转成list,数据量大时莫用 ... print(k,v) ... k1 18 k4 (11, 22, 33, 44) 2 True k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}] >>>
补充关于布尔值：
8、根据序列，创建字典，并指定统一的值
>>> v = dict.fromkeys(["k1",123,"999"],123) #分别指定列表中元素作为key，而123作为value，创建新的字典 >>> print(v) {'999': 123, 'k1': 123, 123: 123} >>> v = dict.fromkeys(("k1",123,"999",),123) #分别指定元祖中元素作为key，而123作为value，创建新的字典 >>> print(v) {'999': 123, 'k1': 123, 123: 123} #生成新的字典 >>>
9、根据key获取值，key不存在时，可以指定默认值(None)
v= dic['k12121312'] print(v) v = dic.get('k1',11111) print(v)
10、删除并获取值
>>> v = dic.pop('k1',90) >>> print(dic,v) {'k2': 'v2'} v1 >>> dic = { ... "k1": 'v1', ... "k2": 'v2' ... } >>> v = dic.pop("k1") >>> print(v) v1 >>> print(dic) {'k2': 'v2'} >>> k,v = dic.popitem() >>> print(dic,k,v) {} k2 v2
11、设置值
#已存在，不设置，获取当前key对应的值
#不存在，设置，获取当前key对应的值
>>> dic = { ... "k1": 'v1', ... "k2": 'v2' ... } >>> v = dic.setdefault('k1111','123') >>> print(dic,v) {'k1111': '123', 'k1': 'v1', 'k2': 'v2'} 123 >>>
12、更新
>>> dic = { ... "k1":'v1', ... "k2":'v2' ... } >>> dic.update({'k1':'11dfe','k3':123}) >>> print(dic) {'k3': 123, 'k1': '11dfe', 'k2': 'v2'} >>> >>> dic.update(k1=236,k3=345,k5="asdf") >>> print(dic) {'k3': 345, 'k5': 'asdf', 'k1': 236, 'k2': 'v2'} >>>
###################整理######################
# 一、数字 # int(..) # 二、字符串 # replace/find/join/strip/startswith/split/upper/lower/format # tempalte = "i am {name}, age : {age}" # # v = tempalte.format(name='william',age=22) # v = tempalte.format(**{"name": 'william1','age': 23}) # print(v) # 三、列表 # append、extend、insert # 索引、切片、循环 # 四、元组 # 忽略 # 索引、切片、循环 以及元素不能被修改 # 五、字典 # get/update/keys/values/items # for,索引 # dic = { # "k1": 'v1' # } # v = "k1" in dic # print(v) # v = "v1" in dic.values() # print(v) # 六、布尔值 # 0 1 # bool(...) # None "" () [] {} 0 ==> False
set集合
set是一个无序且不重复的元素集合
作用：去重，关系运算
#定义：
知识点回顾
可变类型是不可hash类型(列表、字典)
不可变类型是可hash类型(数字、字符串、元祖)
#定义集合：
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1、每个元素必须是不可变类型(可hash,可作为字典的key)
2、没有重复的元素
3、无序
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
#优先掌握的操作
#1、长度len
#2、成员运算in和not in
#3、 &交集
#4、 |并集
#5、 -差集
#6、 ^对称差集
#7、 ==
#8、 父集： >,>=
#9、 子集： <,<=
基本操作
1、添加(add())
s = set(['william', 'zhurui', 'grace']) print(s) 运行结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {'william', 'zhurui', 'grace'} s = {1,2,3,4,5,6} s.add('s') #添加字符串s s.add('3') #添加字符串3 s.add(3) #添加数字3，原来集合中有元素3，新的集合是去重后的结果 print(s) 输出结果： {1, 2, 3, 4, 5, 6, '3', 's'}
2、添加多项(update())
s1 = {1,2}
s2 = {1,2,3}
s1.update(s2)
print(s1)
s1 = {1,2}
s2 = {1,2,3}
s1.update([1,2,3,4])
s1.add() #更新一个值时用到
s1.union(s2) #不更新
输出结果为：
C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py
{1, 2, 3, 4}
3、清空(clear())
1 s = {1,2,3,4,5,6} 2 s.clear() 3 print(s) 4 输出结果： 5 C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py 6 set()
4、删除(pop(),remove(),discard())
①pop() 随机删
1 s = ['william', 12, 13, 14, 16, 89] 2 s1 = set(s) 3 print(s1) 4 输出结果： 5 C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py 6 {12, 13, 14, 16, 'william', 89} 7 s1.pop() 8 print(s1) 9 输出结果为： 10 C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py 11 {12, 13, 'william', 14, 16, 89} 12 {13, 'william', 14, 16, 89}
注：pop是随机删除集合中的某个元素；
②remove() 指定删除
s = ['william', 12, 13, 14, 16, 89] s1 = set(s) print(s1) s1.remove('william') print(s1) 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {89, 12, 13, 14, 16, 'william'} {89, 12, 13, 14, 16} #跟上面集合对比，william元素被删除
name.remove('zhurui') #删除元素不存在会报错
s = ['william', 12, 13, 14, 16, 89] s1 = set(s) s1.remove('zhurui') #zhurui这个元素不存在 print(s1) 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py Traceback (most recent call last): File "C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py", line 44, in <module> s1.remove('zhurui') KeyError: 'zhurui'
name.discard('zhurui') #删除元素不存在不会报错
s = ['william', 12, 13, 14, 16, 89] s1 = set(s) s1.discard('zhurui') #删除一个没有的元素，执行结果并没有报错 print(s1) 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {'william', 12, 13, 14, 16, 89}
注：用remove删除时，当元素不存在，会报错；
③discard()
s = ['william', 12, 13, 14, 16, 89] s1 = set(s) s1.discard('zhurui') #删除一个没有的元素，执行结果并没有报错 print(s1) 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {'william', 12, 13, 14, 16, 89}
注：用discard删除不存在的元素时，不会出现报错
5、长度(len())
name_1 = [1,2,3,4,7,8,7,10] name_1 = set(name_1) print(len(name_1)) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py 7
6、x in s
>>> name_1 = [1,2,3,4,7,8,7,10] >>> name_1 = set(name_1) >>> 1 in name_1 True
name_1 = [1,2,3,4,7,8,7,10] name_1 = set(name_1) # print(len(name_1)) print(1 in name_1) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py True
7、x not in s
name_1 = [1,2,3,4,7,8,7,10] name_1 = set(name_1) # print(len(name_1)) print(13 not in name_1) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py True
关系测试
1、交集(intersection())
python_l=['lcg','szw','zjw','lcg'] linux_l=['lcg','szw','sb'] p_s = set(python_l) l_s = set(linux_l) print(p_s, l_s) print(p_s.intersection(l_s)) #跟&方法方法一样都是求交集 print(p_s&l_s) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {'zjw', 'szw', 'lcg'} {'szw', 'lcg', 'sb'} {'szw', 'lcg'} {'szw', 'lcg'}
2、并集(union())
python_l=['lcg','szw','zjw','lcg'] linux_l=['lcg','szw','sb'] p_s = set(python_l) l_s = set(linux_l) print(p_s, l_s) print(p_s.union(l_s)) print(p_s|l_s) #并集符号形式表示 输出结果为： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {'lcg', 'zjw', 'szw'} {'sb', 'lcg', 'szw'} {'lcg', 'sb', 'zjw', 'szw'} {'lcg', 'sb', 'zjw', 'szw'}
3、差集(difference())
python_l=['lcg','szw','zjw','lcg'] linux_l=['lcg','szw','sb'] p_s = set(python_l) l_s = set(linux_l) print('差集', p_s-l_s) print(p_s.difference(l_s)) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py 差集 {'zjw'} {'zjw'} print('差集', l_s-p_s) print(l_s.difference(p_s)) 输出结果： 差集 {'sb'} {'sb'}
4、交叉补集(symmetric_difference()) #把两个集合没有交集的数值取出来
python_l=['lcg','szw','zjw','lcg'] linux_l=['lcg','szw','sb'] p_s = set(python_l) l_s = set(linux_l) print(p_s, l_s) print(p_s.symmetric_difference(l_s))
print(p_s^l_s) 输出结果： C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py {'lcg', 'zjw', 'szw'} {'lcg', 'szw', 'sb'} {'zjw', 'sb'} #将两个集合对比，剔除相同部分，差异的部分组成新的集合就是我们想要的结果
5、(difference_update())
python_l = ['lcg', 'szw', 'zjw', 'lcg'] linux_l = ['lcg', 'szw', 'sb'] p_s = set(python_l) l_s = set(linux_l) print('差集', p_s-l_s) p_s.difference_update(l_s) print(p_s)
6、isdisjoint() #判断两个集合是否有交集，没有交集，则返回True
s1 = {1,2,3,}
s2 = {3,4,5,6}
print(s1.isdisjoint(s2)) #判断二者有无共有部分
输出结果：
C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py
False #两个集合有交集，返回False
7、issubset() #判断一个集合是否是另一个集合的子集
s1 = {1,2}
s2 = {1,2,3}
print(s1.issubset(s2)) #判断s1 是否是s2的子集，相当于s1 <= s2
输出结果：
C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py
True
8、issuperset() #判断一个集合是否是另一个集合的父集
s1 = {1,2,3}
s2 = {1,2}
print(s1.issuperset(s2))#s1是s2的父集，为真则返回True
输出结果：
C:Python35python3.exe C:/Users/ZR/PycharmProjects/python全栈开发/day15/set_集合.py
True