二、变量、整数、字符串、列表、字典、集合。

二、变量、整数、字符串、列表、字典、集合。

一、输入与输出

print是输出的意思input是输入的意思

1.1：输出

1.2：输出

二、变量

例如：

2.2：变量定义规则

三、数数类型（int）

3.1：long（长整型）

注意：在Python3里不再有long类型了，全都是int

3.1：int（整型）

在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

四、字符串（str）

在Python中，加了引号的字符都被认为是字符串。存储少量的数据，进行简单的操作。

注意：双引号、单引号、没有任何区别，作用就是字符串必须用引号。

多引号只用于多行字符串。

4.1：字符串拼接

数字可以进行加减乘除等运算，字符串只能进行"相加"和"相乘"运算。

4.2：切片

切片操作（slice）可以从一个字符串中获取子字符串（字符串的一部分）。我们使用一对方括号、起始偏移量start、终止偏移量end 以及可选的步长step 来定义一个分片。

格式： [start:end:step]

顾首不顾尾（结尾多取一个）s[起始索引:结束索引+1]s[起始索引:结束索引+1:步长][:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串；[start:] 从start 提取到结尾；[:end] 从开头提取到end - 1；[start:end] 从start 提取到end - 1；[start:end:step] 从start 提取到end - 1，每step 个字符提取一个；左侧第一个字符的位置/偏移量为0，右侧最后一个字符的位置/偏移量为-1；

#!/user/bin/env python# -*- coding:utf-8 -*-s = 'alexwusirritian'#取出alexs5 = s[0:4]#如果是从头开始可以不写0s5 = s[:4]print(s5)#取出wusirs6 = s[4:9]print(s6)#取出所有s7 = s[:]print(s7)#取出aews8 = s[:5:2]print(s8)#取出naits9 = s[-1:-5:-1]print(s9)#取出tians10 = s[-4:]print(s10)

输入一个字符串，返回倒序排序的结果，：如：‘abcdef’ 返回：'fedcba'

>>> G = "abcd">>> print(G)abcd>>> S = G[::-1]>>> print(S)dcba>>>

test = 'nothing is impossible'#取出nothingtest1 = test[:8]print(test1)#取出istest2 = test[8:11]print(test2)#取出impossibletest3 = test[-10:]print(test3)#取出所有test4 = test[:]print(test4)#反向取出所有test5 = test[-1:-22:-1]print(test5)test6 = test[::-1]print(test6)#输出结果为：nothing is impossiblenothing is impossibleelbissopmi si gnihtonelbissopmi si gnihton

4.3：字符串的常用方法

capitalize：首字母大写其余字母小写

s = 'alexWUsir's1 = s.capitalize()print(s1)#输出结果为：Alexwusir

test = 'nothing is impossible'test1 = test.capitalize()print(test1)#输出结果为：Nothing is impossible

swapcase：大小写翻转

s = 'alexWUsir's2 = s.swapcase()print(s2)

#输出结果为：ALEXwuSIR

test = 'Nothing Is imPOssiBle'test1 = test.swapcase()print(test1)#输出结果为：nOTHING iS IMpoSSIbLE

title：非字母隔开的每个单词的首字母大写

s = 'alex wusir*taibai2ritian's3 = s.title()print(s3)

#输出结果为：Alex Wusir*Taibai2Ritian

test = 'No#th-in)g I$s imPO*ss+iB%le'test1 = test.title()print(test1)#输出结果为：No#Th-In)G I$S Impo*Ss+Ib%Le

center：设置总长度，并居中

s = 'alexWUsir's4 = s.center(30,)print(s4)

#长度为30#输出结果为： alexWUsir

#长度为30，填充物为*s = 'alexWUsir's4 = s.center(30,'*')print(s4)#输出结果为：**********alexWUsir***********

#长度为50，填充物为+test = 'Nothing is impossible'test1 = test.center(50,'+')print(test1)#输出结果为：++++++++++++++Nothing is impossible+++++++++++++++

upper()：全大写

s = 'alexWUsir's5 = s.upper()print(s5)#输出结果为：ALEXWUSIR

#验证码例子s = 'alexWUsir'code = 'AwEqr'username= input('请输入用户名:')your_code = input('请输入验证码：')if username == 'alex' and your_code.upper() == code.upper(): print('验证成功')#输出结果为：请输入用户名:alex请输入验证码：aweqr验证成功

test = 'Nothing is impossible'test1 = test.upper()print(test1)#输出结果为：NOTHING IS IMPOSSIBLE

lower()：全小写

test = 'NOTHING IS IMPOSSIBLE'test1 = test.lower()print(test1)#输出结果为：nothing is impossible

startswith：检测字符串是否是由相同的开头，返回True或False

s = 'alexWUsir's6 = s.startswith('a')s7 = s.startswith('alex')s8 = s.startswith('W', 4,)print(s6,s7,s8)#输出结果为：True True True

test = 'Nothing is impossible'test1 = test.startswith('i')test2 = test.startswith('N')#第14个元素是不是以po开头test3 = test.startswith('po',13)print(test1)print(test2)print(test3)#输出结果为：FalseTrueTrue

endswith：检测字符串是否是由相同的结尾，返回True或False

test = 'Nothing is impossible'#整个字符串是否以e结尾test1 = test.endswith('e')#整个字符串是否以N结尾test2 = test.endswith('N')#第二个元素是否以t开头第四个元素是否以h结尾test3 = test.endswith('th',2,4)print(test1)print(test2)print(test3)#输出结果为：TrueFalseTrue

str = "this is string example....wow!!!"suffix = "wow!!!"print (str.endswith(suffix))print (str.endswith(suffix,20))suffix = "is"print (str.endswith(suffix, 2, 4))print (str.endswith(suffix, 2, 6))#输出结果为：TrueTrueTrueFalse

strip：默认去除字符串前后的空格，换行符，制表符

s = ' alexWUsir\t'print(s)#输出结果为： alexWUsir

s = ' alexWUsir\t'print(s)s7 = s.strip()print(s7)#输出结果为： alexWUsir alexWUsir

username = input('>>>').strip()password = input('>>>').strip()if username == '郭海亮' and password == '123': print('登录成功')#输出结果为：>>>郭海亮>>>123登录成功

ss = 'abc郭海亮q'ss1 = ss.strip('abqc')print(ss1)#输出结果为：郭海亮

str = "*****this is string example....wow!!!*****"print (str.strip('*'))#输出结果为：this is string example....wow!!!

lstrip()：默认只去除左边的空格

str = " this is string example....wow!!! "print( str.lstrip() )str = "88888888this is string example....wow!!!8888888"print( str.lstrip('8') )#输出结果为：this is string example....wow!!! this is string example....wow!!!8888888

rstrip()：默认只去除右边的空格

str = " this is string example....wow!!! "print (str.rstrip())str = "*****this is string example....wow!!!*****"print (str.rstrip('*'))#输出结果为： this is string example....wow!!!*****this is string example....wow!!!

replace：字符串替换

s = 'alex 分甘共苦老地方 alex 风刀霜剑卡乐芙's8 = s.replace('alex', 'SB')print(s8)#输出结果为：SB 分甘共苦老地方 SB 风刀霜剑卡乐芙#只替换第一个s = 'alex 分甘共苦老地方 alex 风刀霜剑卡乐芙's9 = s.replace('alex', 'SB',1)print(s9)#输出结果为：SB 分甘共苦老地方 alex 风刀霜剑卡乐芙

str = "this is string example....wow!!! this is really string"print (str.replace("is", "was"))print (str.replace("is", "was", 3))#输出结果为：thwas was string example....wow!!! thwas was really stringthwas was string example....wow!!! thwas is really string

split： 分隔，str ---> list

s1 = 'alex wusir taibai ritian's2 = 'alex,wusir,taibai,ritian's3 = 'alexwusirtaibairitian's4 = 'alexwusirtaibairitian'l1 = s1.split()l2 = s2.split(',')l3 = s3.split('a')l4 = s4.split('a',2) #以a为分隔符，分割两次print(l1)print(l2)print(l3)print(l4)#输出结果为：['alex', 'wusir', 'taibai', 'ritian']['alex', 'wusir', 'taibai', 'ritian']['', 'lexwusirt', 'ib', 'iriti', 'n']['', 'lexwusirt', 'ibairitian']

str = "this is string example....wow!!!"print (str.split( ))print (str.split('i',1))print (str.split('w'))#输出结果为：['this', 'is', 'string', 'example....wow!!!']['th', 's is string example....wow!!!']['this is string example....', 'o', '!!!']

join：分割，list---> str

注意：列表里面的元素必须都是字符串

s = '郭海亮's1 = '-'.join(s)print(s1)#输出结果为：郭-海-亮

l1 = ['alex', 'wusir', 'ritian']s10 = ' '.join(l1)print(s10,type(s10))#输出结果为：alex wusir ritian

str = "-" # 字符串序列seq = ("a", "b", "c")print (str.join(seq))#输出结果为：a-b-c

find：通过元素找索引，找不到返回-1

s = 'alexwausir's11 = s.find('e')s12 = s.find('ex')s13 = s.find('QWE')print(s11,type(s11))print(s12,type(s12))print(s13,type(s13))#输出结果为：2 2 -1

str1 = "Runoob example....wow!!!"str2 = "exam"print (str1.find(str2))print (str1.find(str2, 5))print (str1.find(str2, 10))#输出结果为：77-1

index：通过元素找索引，找不到会报错

#从列表中找出某个值第一个匹配项的索引位置）a = ["q","w","r","t","y"]print(a.index("r"))

str1 = "this is string example....wow!!!"str2 = "exam"print (str1.index(str2))#从索引10开始找print (str1.index(str2, 10))#从索引40开始找print (str1.index(str2, 40))#输出结果为：1515Traceback (most recent call last): File "F:/Python/My road of Python/day02/test.py", line 12, in print (str1.index(str2, 40))ValueError: substring not found

len：测量个数

s = 'alexwausir'print(len(s))#输出结果为：10

>>>str = "runoob">>> len(str) # 字符串长度6>>> l = [1,2,3,4,5]>>> len(l) # 列表元素个数5

count：（数）（方法统计某个元素在列表中出现的次数）

s = 'alexwausir'print(s.count('a'))#输出结果为：2

str = "this is string example....wow!!!"sub = "i"print ("str.count(sub, 4, 40) : ", str.count(sub, 4, 40))sub = "wow"print ("str.count(sub) : ", str.count(sub))#输出结果为：str.count(sub, 4, 40) : 2str.count(sub) : 1

format：格式化输出

s = "我叫{}，今年{}，爱好{}"#第一种用法s12 = s.format('海亮', '23', '女')print(s12)#第二种用法s1 = "我叫{0}，今年{1}，爱好{2},我依然叫{0}"s13 = s1.format('海亮', '23', '女')print(s13)#第三种用法s3 = "我叫{name}，今年{age}，爱好{hobby}"s14 = s3.format(age=23,hobby='girl',name='海亮')print(s14)#输出结果为：我叫海亮，今年23，爱好女我叫海亮，今年23，爱好女,我依然叫海亮我叫海亮，今年23，爱好girl

# 不设置指定位置，按默认顺序>>>"{} {}".format("hello", "world") 'hello world' # 设置指定位置>>> "{0} {1}".format("hello", "world") 'hello world' # 设置指定位置>>> "{1} {0} {1}".format("hello", "world") 'world hello world'

print("网站名：{name}, 地址 {url}".format(name="个人小站", url="guohailiang.club"))# 通过字典设置参数site = {"name": "个人小站", "url": "guohailiang.club"}print("网站名：{name}, 地址 {url}".format(**site))# 通过列表索引设置参数my_list = ['个人小站', 'guohailiang.club']print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的

isalnum：检验字符串是否由字母和数字组成

name = '123'print(name.isalnum())#输出结果为：True

str = "runoob2016"print (str.isalnum())str = "runoob.com"print (str.isalnum())#输出结果为：TrueFalse

isalpha：检测字符串是否只由字母组成

name = '123'print(name.isalpha())#输出结果为：False

test = 'Nothing is impossible'print(test.isalpha())#输出结果为：False

isdigit：检测字符串是否只由数字组成

name = '123'print(name.isdigit())#输出结果为：True

str = "123456"print (str.isdigit())str = "Runoob example....wow!!!"print (str.isdigit())#输出结果为：TrueFalse

sort()正序排序列表中的元素

l1 = [1, 9, 8, 4, 3, 2, 6,]l1.sort()print(l1)#输出结果为：[1, 2, 3, 4, 6, 8, 9]

list1 = ['Google','Runoob','Taobao','Baidu']list1.sort()print ("列表排序后 : ", list1)#输出结果为：列表排序后 : ['Baidu', 'Google', 'Runoob', 'Taobao']

sort()倒叙排序列表中的元素

l1 = [1, 9, 8, 4, 3, 2, 6,]l1.sort(reverse=True)print(l1)#输出结果为：[9, 8, 6, 4, 3, 2, 1]

reverse()翻转列表中的元素

l1 = [1, 9, 8, 4, 3, 2, 6,]l1.reverse()print(l1)#输出结果为：[6, 2, 3, 4, 8, 9, 1]

4.4：数字、字符串、布尔之间的转换

str ---> int

前提是：转换前的字符串全都由数字组成

int ---> str

所有数字都能转换为字符串str(int)

int ---> bool

0---> False非0 ---> Truebool(int)

print(bool(100))print(bool(-1))print(bool(0))#输出结果为：TrueTrueFalse

bool --> int

True ---> 1False --->0int(bool)

print(int(True))print(int(False))#输出结果为：10

str ---> bool

非空---> True空字符串---> Falsebool('str')

print(bool(''))print(bool('fdsaf'))#输出结果为：FalseTrue

bool --->str

没有意义

print(str(True),type(str(True)))#输出结果为：True

str ---> list

split

list --> str

join

五、布尔类型（bool）

两个值 ，一个True(真)，一个False(假), 主要用记逻辑判断；

六 、列表（list）

包含在[ ]内，用逗号分隔。

里面可以存放各种数据类型比如：li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

用途：（存多个值，可以修改）

6.1：列表语法

6.2：列表操作包含以下函数

6.3：列表包含以下方法

6.4：查看

#按照索引，切片（步长），for 循环遍历。l = ['WuSir', 'alex', 'OldBoy', 'barry']for i in l: print(i)#输出结果为：WuSiralexOldBoybarry

6.5：增加

li = [1,'a','b',2,3,'a']

insert#按照索引去增加li.insert(0,55)print(li)#输出结果为：[55, 1, 'a', 'b', 2, 3, 'a']append#增加到最后li.append('aaa') print(li)#输出结果为：[1, 'a', 'b', 2, 3, 'a', 'aaa']#增加到最后li.append([1,2,3]) print(li)#输出结果为：[1, 'a', 'b', 2, 3, 'a', [1, 2, 3]]extend#迭代的去增li.extend(['q,a,w']) li.extend(['q,a,w','aaa'])li.extend('a')li.extend('abc')li.extend('a,b,c')print(li)#输出结果为：[1, 'a', 'b', 2, 3, 'a', 'q,a,w', 'q,a,w', 'aaa', 'a', 'a', 'b', 'c', 'a', ',', 'b', ',', 'c']

# append()l = ['WuSir', 'alex', 'OldBoy', 'barry']l.append('景女神')print(l)l.append(1)print(l)l.append([1, 2, 3])print(l)#输出结果为：['WuSir', 'alex', 'OldBoy', 'barry', '景女神']['WuSir', 'alex', 'OldBoy', 'barry', '景女神', 1]['WuSir', 'alex', 'OldBoy', 'barry', '景女神', 1, [1, 2, 3]]# insert()l = ['WuSir', 'alex', 'OldBoy', 'barry']l.insert(1, '葫芦')print(l)#输出结果为：['WuSir', '葫芦', 'alex', 'OldBoy', 'barry']# extend()l = ['WuSir', 'alex', 'OldBoy', 'barry']l.extend('abc')print(l)l.extend([1, '2122', 56])print(l)#输出结果为：['WuSir', 'alex', 'OldBoy', 'barry', 'a', 'b', 'c']['WuSir', 'alex', 'OldBoy', 'barry', 'a', 'b', 'c', 1, '2122', 56]

6.6：修改

li = [1,'a','b',2,3,'a']li[1] = 'dfasdfas'print(li)#输出结果为：[1, 'dfasdfas', 'b', 2, 3, 'a']li = [1,'a','b',2,3,'a']li[1:3] = ['a','b']print(li)#输出结果为：[1, 'a', 'b', 2, 3, 'a']

l = ['WuSir', 'alex', 'OldBoy', 'barry']#按照索引改l[0] = '日天'print(l)l[2] = '老男孩'print(l)#输出结果为['日天', 'alex', 'OldBoy', 'barry']['日天', 'alex', '老男孩', 'barry']# 按照切片去改l = ['WuSir', 'alex', 'OldBoy', 'barry']l[:3] = 'abcdgfdljgkfdgjlfdlgjfdsaklfdjskladsfj'l[:3] = 'a'l[:3] = [11, 22, 33, 44]#加步长 必须一一对应l[:3:2] = 'ab'print(l)#输出结果为：['a', 22, 'b', 44, 'f', 'd', 'l', 'j', 'g', 'k', 'f', 'd', 'g', 'j', 'l', 'f', 'd', 'l', 'g', 'j', 'f', 'd', 's', 'a', 'k', 'l', 'f', 'd', 'j', 's', 'k', 'l', 'a', 'd', 's', 'f', 'j', 'barry']

6.7：删除

li = [1,'a','b',2,3,'a']

#按照索引popl1 = li.pop(1)print(l1)#输出结果为：a#按照位置、切片deldel li[1:3]print(li)#输出结果为：[1, 2, 3, 'a']#按照元素removeli.remove('a') print(li)#输出结果为：[1, 'b', 2, 3, 'a']#清空列表clearli.clear()#输出结果为：

#将索引为奇数对应的元素删除l1 = [11, 22, 33, 44, 55]del l1[1::2]print(l1)#输出结果为：[11, 33, 55]

#再循环一个列表时，不要改变列表的大小，这样会影响结果。l1 = [11, 22, 33, 44, 55]for i in range(len(l1)): print(i) print(l1) if i % 2 == 1: del l1[i] print(i) print(l1)print(l1)#输出结果为：0[11, 22, 33, 44, 55]0[11, 22, 33, 44, 55]1[11, 22, 33, 44, 55]1[11, 33, 44, 55]2[11, 33, 44, 55]2[11, 33, 44, 55]3[11, 33, 44, 55]3[11, 33, 44]4[11, 33, 44]4[11, 33, 44][11, 33, 44]

l1 = [11, 22, 33, 44, 55]for i in range(len(l1)-1,-1,-1): if i % 2 == 1: del l1[i]print(l1)#输出结果为：[11, 33, 55]

dic = {'k1': 'v1', 'k2': 'v2', 'k3':'v3', 'name':'alex'}s1 = 'abc'print('a' in s1)l1 = []for i in dic: if 'k' in i: l1.append(i)print(l1)for i in l1: del dic[i]print(dic)#dic = dict.fromkeys('abc',666)print(dic)#输出结果为：True['k1', 'k2', 'k3']{'name': 'alex'}{'a': 666, 'b': 666, 'c': 666}

6.8：列表的嵌套

l1 = [1, 2, 'alex', ['WuSir', 'taibai', 99], 6]# 将alex该成Alexl1[2] = l1[2].capitalize()print(l1)#输出结果为：[1, 2, 'Alex', ['WuSir', 'taibai', 99], 6]

l1 = [1, 2, 'alex', ['WuSir', 'taibai', 99], 6]#将'WuSir'变成全部大写。l1[3][0] = l1[3][0].upper()print(l1)#输出结果为：[1, 2, 'alex', ['WUSIR', 'taibai', 99], 6]

l1 = [1, 2, 'alex', ['WuSir', 'taibai', 99], 6]# 99让其通过数字加1的方式变成 '100'.l1[3][-1] = str(l1[3][-1] + 1)print(l1)#输出结果为：[1, 2, 'alex', ['WuSir', 'taibai', '100'], 6]

七、字典（dict）

key-values存储，可以存储大量的的关系型数据，查询速度非常快。字典的键 必须是唯一的，不可重复，value 可以为任意数据类型或者对象。字典的键只能是不可变的数据类型：数据类型的分类：不可变（可哈希的）得数据类型：int str tuple bool可变的（不可哈希的）数据类型：dict，list，set

定义：在{}，用逗号隔开，每一个元素的形式都是键值对，即key：value。用途：可以有多个值，这一点与列表相同，但可以是任意数据类型特征：每一个值都有唯一一个对应关系，即key。key、字符串、数字是不可变类型。

7.1：字典包含了以下内置函数

7.2：字典包含了以下内置方法

7.3：查看

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}print(dic['name'])print(dic.get('name'))#输出结果为：老男孩老男孩

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}# 类似于列表的一个容器，没有索引print(dic.keys())for i in dic.keys(): print(i)for i in dic: print(i)#输出结果为：dict_keys(['name', 'age', 'sex'])nameagesexnameagesex

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}print(dic.values())print(dic.items())for i in dic.items(): print(i)#输出结果为：dict_values(['老男孩', 10000, '男'])dict_items([('name', '老男孩'), ('age', 10000), ('sex', '男')])('name', '老男孩')('age', 10000)('sex', '男')

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}# 分别赋值a, b = 1 ,3a, b = [22, 33]print(a,b)for k, v in dic.items(): print(k, v)#输出结果为：22 33name 老男孩age 10000sex 男

7.4：增加

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}# 无责增加，有责修改。dic['hobby'] = 'old_girl'dic['name'] = 'alex'print(dic)#输出结果为：{'name': 'alex', 'age': 10000, 'sex': '男', 'hobby': 'old_girl'}# 有key则不修改，无责添加。dic.setdefault('high')dic.setdefault('high', 169)dic.setdefault('name', 'wusir')print(dic)#输出结果为：{'name': 'alex', 'age': 10000, 'sex': '男', 'hobby': 'old_girl', 'high': None}

7.5：修改

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}# 无责增加，有责修改.dic['name'] = 'alex'print(dic)#输出结果为：{'name': 'alex', 'age': 10000, 'sex': '男'}

dic = {"name": "jin", "age": 18,"sex": "male"}dic2 = {"name": "alex", "weight": 75}#将dic里面的键值对覆盖并更新到dic2中，dic不变 。dic2.update(dic)print(dic)print(dic2)#输出结果为：{'name': 'jin', 'age': 18, 'sex': 'male'}{'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

7.6：删除

dic = { 'name': '老男孩', 'age': 10000, 'sex': '男',}# 返回值print(dic.pop('name')) dic.pop('name1',None)print(dic)#输出结果为：老男孩{'age': 10000, 'sex': '男'}#popitem 随机删除 有返回值print(dic.popitem())print(dic)#输出结果为：('sex', '男'){'name': '老男孩', 'age': 10000}#clear删除整个字典dic.clear()print(dic)#输出结果为：{}#按照键去删除键值对del dic['name']print(dic)#输出结果为：{'age': 10000, 'sex': '男'}

7.7：字典的嵌套

dic = {'name_list':['高猛', '于其',], 1:{ 'alex': '李杰', 'high': '175', }}###为['高猛', '于其',] 追加一个元素'wusir'，2，### 为{'alex': '李杰','high': '175' } 增加一个键值对 'sex': man，dic['name_list'].append('wusir')print(dic)print(dic[1])dic[1]['sex'] = 'man'print(dic)#输出结果为：{'name_list': ['高猛', '于其', 'wusir'], 1: {'alex': '李杰', 'high': '175'}}{'alex': '李杰', 'high': '175'}{'name_list': ['高猛', '于其', 'wusir'], 1: {'alex': '李杰', 'high': '175', 'sex': 'man'}}

八、集合

8.1：作用

可以包含多个元素，用逗号分割，将不同的值存放在一起做关系运算。

1.每个元素必须是不可变类型（可hash，可作为字典的key）

2.没有重复的元素

3.无序

8.2：用法

|（并集）&（交集）-（差集）^（对称差集）

集合add方法：是把要传入的元素做为一个整个添加到集合中，例如：

>>> a = set('boy')>>> a.add('python')>>> aset(['y', 'python', 'b', 'o'])

集合update方法：是把要传入的元素拆分，做为个体传入到集合中，例如：

>>> a = set('boy')>>> a.update('python')>>> aset(['b', 'h', 'o', 'n', 'p', 't', 'y'])

集合删除操作方法：remove

set(['y', 'python', 'b', 'o'])>>> a.remove('python')>>> aset(['y', 'b', 'o'])

8.3：例子

bingo = {"人","生","苦","短","我","用","python"}awful = {"python","要","被","我","所","用"}

1.求bingo和awful的交集

>>> bingo = {"人","生","苦","短","我","用","python"}>>> awful = {"python","要","被","我","所","用"}>>> print(bingo & awful){'我', '用', 'python'}>>>

2.求bingo和awful的并集

>>> bingo = {"人","生","苦","短","我","用","python"}>>> awful = {"python","要","被","我","所","用"}>>> print(bingo | awful){'用', '所', '生', '人', '我', '要', 'python', '苦', '被', '短'}>>>

3.求只在bingo中出现的元素集合

>>> bingo = {"人","生","苦","短","我","用","python"}>>> awful = {"python","要","被","我","所","用"}>>> print(bingo - awful){'短', '人', '苦', '生'}>>>

4.求没有同时存在bingo和awful中的元素集合

>>> bingo = {"人","生","苦","短","我","用","python"}>>> awful = {"python","要","被","我","所","用"}>>> print(bingo ^ awful){'所', '要', '生', '人', '被', '苦', '短'}>>>

5.解压

test,*_={'包子','饺子','丸子',}print(test)

九、数据类型嵌套

作者：HaydenGuo

每一个前十年都想不到后十年我会演变成何等模样，可知人生无常，没有什么规律，没有什么必然。

只要我还对新鲜的知识、品格的改进、情感的扩张、有胃口，这日子就是值得度过的。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。