转载

01 Python 基础数据类型

基础数据类型,有7种类型,存在即合理。

1.int 整数

主要是做 运算 的 。比如加减乘除,幂,取余  + - * / ** %...

2.bool 布尔值

判断真假以及作为 条件变量

3.str 字符串

存储少量的数据。比如'password'... 操作简单,便于传输。

4.list 列表

[1,2,'alex',{name:'zhang'}] 存放大量的数据,大量的数据放到列表中便于操作

5.tuple 元组

也叫只读列表。(1,2,'alex',{name:'zhang'}) 一些重要的数据或者不想被更改的数据,使用元组

6.dict 字典

{‘name_list’:'[zhang,lisi]'},  存储关系型的数据 ,查询速度非常快,二分查找。

7.set 集合

交集,并集,差集...

数据类型的分类:

可变数据类型(不可哈希):list,dict,set

不可变数据类型(可哈希):int,bool,str,tuple

容器类型:

容器类(承载各种数据类型):list,tuple,dic

 一、int整形

主要用于计算,计数,+ - * / %  ** ....

32位系统,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647

64位系统,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807

float:浮点数,复数

bit_length():转化成二进制的最小位数

二、 bool 布尔值

数据类型转换:

int <---> str:  int(str)、str(int)

int <---> bool: 非零即True,零为False    bool(1).

bool <---> str:

①str ---> bool: 非空即True ,空字符串对应 False。 print(bool('Alex'))  结果为 True

②bool ---> str:只能打印True和False,没有什么实际意义

1 例子:
2 n = str(1)           # 1
3 n = bool(1)            #True
4 n = bool('')          # False. 空字符串是False,其他都是True

三、 str 字符串

在python中,凡是用引号引起来的数据都是字符串。 单引号,双引号,三引号 引起来没有任何区别。

1 s1 = '小明'
2 s2 = "小明"
3 s3 = """小明"""
4 print(s1,s2,s3)         #都是小明。 小明,小明,小明

1. 单双引号配合使用

1 msg = "My name is Ming , I'm 73 years old!"       # 里面是单引号,所以外面用双引号比较好

2. 三引号用于换行的字符串

 1 msg = ''' 
 2 今天我想写首小诗,
 3 歌颂我的同桌,
 4 你看他那乌黑的短发,
 5 '''
 6 print(msg)
结果显示:
今天我想写首小诗,
歌颂我的同桌,
你看他那乌黑的短发,

3.字符串相加和相乘

相加  :拼接。

s1 = 'a'
s2 = 'b'
print(s1 + s2)      #ab

相乘

s3 = 'a'
print(s3*8)         # aaaaaaaa

4.字符串重要操作 *****

4.1 字符串的取值(索引、切片、步长)

①按照 索引取值

1 s = 'abcdefgh'
2 s1 = s[0]          # 取第一个值
3 s2 = s[-1]         # 取最后一个值

②按 切片取值 ,顾头不顾尾。切片,也就是取连续的多个值

 1 s = 'abcdefgh'
 2 s1 = s[0:6]     # 按切片取值,顾头不顾尾
 3 s2 = s[:6]      # 从0开始取值,0可以省略
 4 s3 = s[6:]      # 从某一索引取到最后的值,冒号后面不跟值
 5 s4 = s[-5:]     # 取最后5个字符串
 6 s5 = s[:]       # 取所有
 7 
 8 print(s1)
 9 print(s2)
10 print(s3)
11 print(s4)
12 print(s5)
结果显示:
abcdef
abcdef
gh
defgh
abcdefgh

对字符串操作,都会产生新的变量,除了赋值以外。

③按照 切片 +步长取值 [起始索引:截止索引:步长]

步长:

(1)默认步长为1

(2)隔一个取1个,步长为2

(3)反向取值,也就是从后向前取,步长为-1

 1 s = 'abcdefgh'
 2 s1 = s[:5:2]    # 从第一个字符到第五个字符,每隔一个字符取一个值。
 3 s2 = s[1::2]    # 从第二个字符到最后一个字符,每隔一个字符取一个值,最后一个字符的位置不能写值。
 4 s3 = s[::2]     # 隔1个,取一个
 5 
 6 print(s1)
 7 print(s2)
 8 print(s3)
结果输出:
ace
bdfh
aceg

倒叙取值,加一个反向步长 *****

 1 s = 'abcdefgh'
 2 s1 = s[::-1]        # 反向全取
 3 s2 = s[-1:-6:-2]    # 划士期
 4 s3 = s[:-5:-1]      # 反向取5个
 5 s4 = s[-1:-5:-1]    
 6 
 7 print(s1)
 8 print(s2)
 9 print(s3)
10 print(s4)
结果输出:
hgfedcba
hfd
hgfe
hgfe

4.2 字符串的常用方法

①capitalize():首字母大写,其他字母小写   ***

②upper()、lower():字母全部大写/小写  *****

1 name = 'Summer'
2 print(name.capitalize())        #Summer
3 print(name.upper())             # SUMMER
4 print(name.lower())             # summer

可用于验证码输入, 如果不使用字符串内置方法,这需要写16个if,代码质量非常low

1 code = 'Summer'.upper()
2 your_code = input('请输入验证码:').upper()
3 if your_code == code:
4     print('验证码验证成功')

③swapcase():大小写反转 **

④title():非字母隔开的首字母大写**

1 s1 = 'sumer aaa#bbbb*cc6ddd'
2 print(s1.title())              # Sumer Aaa#Bbbb*Cc6Ddd

⑤startswith()、endswith():判断是否以...开头或结尾,返回bool值

endswith()的用法与startswith()相同   *****

s = 'summer wusir*nanhai21shui'
s1 = s.startswith('a')  
s2 = s.endswith('i')  

# 切片,取索引访问1~4,再判断是否以i开头
s3 = s.startswith('i', 1, 4)  

# 切片,取索引范围5~结束,结束位置参数没给,默认一直取到尾
s4 = s.startswith('w', 5)  

print(s1,s2,s3,s4)              # False True False False

⑥通过元素找索引( find( ),index( ) ):找到第一个元素就返回,返回int        *****

1 name = "summer"
2 print(name.find('u'))          # 返回u在字符串中的位置,返回1
3 print(name.find('mm'))          # 返回lD在字符串中的位置,返回2
4 print(name.find('w'))          # 返回w在字符串中的位置,字符串中没有w,返回-1
5 print(name.find('e', 1, -1))      # 从位置1到最后查找2的位置,返回4

index ()的用法和 find ()相同,只是 index ()没有找到会报错, find ()没有找到返回 -1

⑦center():字符串居中,前后填充自定义字符 **

总宽度为30,并且字符串居中,不足30, 默认用空格填充

1 s = 'laoshi'
2 s1 = s.center(30)
3 print(s1)           #            laoshi            

#使用*填充

1 s = 'laoshi'
2 s2 = s.center(30,'*')
3 print(s2)               #************laoshi************

如果宽度小于字符串,按照原来的字符串显示

1 s = 'laoshi'
2 s2 = s.center(3,'*')
3 print(s2)               #laoshi

⑧strip(): 去除字符串开头和结尾的 空格 . 换行符 . 制表符 ,不能删除中间的

在input程序中,会经常使用, 如果用户输入的,不小心包含了空格,会导致验证失败,下面加入strip(), 即使输入有空格,也可以验证通过

1 name = input('请输入用户名:').strip()
2 
3 if name == 'summer':
4     print('ok')

类似功能的2个的方法

lstrip() 去除左边的空格、换行符、tab键

rstrip() 去除右边的空格、换行符、tab键

strip()还可以去除指定的字符串

1 s = 'laoshijintianzai'
2 s1 = s.strip('l') #去除字符串l
3 print(s1)         #aoshijintianzai
4 
5 strip()会同时向左右2边,挨个挨个字符寻找字符串l 如果发现了l就去除,如果没有发现终止寻找                    

⑨split(): 字符串分割成列表,默认按照空格分割 ,实现字符串 --- >列表的转化    *****

# 默认按照空格分隔

1 s1 = 'spring summer autumn winter'
2 l1 = s1.split()
3 
4 print(l1)  # ['spring', 'summer', 'autumn', 'winter']

# 指定分割符

1 s1 = 'spring,summer,autumn,winter'
2 l1 = s1.split(',')
3 
4 print(l1)  # ['spring', 'summer', 'autumn', 'winter']

# 指定字符串a

1 s1 = 'springasummeraautumnawinter'
2 l1 = s1.split('a')
3 
4 print(l1)  # ['spring', 'summer', '', 'utumn', 'winter']

注意:如果关键字左边没有字符串,那么结果为[],也就是空字符串。结果不包含关键字,被剔除了

⑩join():自定制连接符,将可迭代对象中的元素连接起来,是列表转化为字符串的方式

1 s='summer'
2 s2='*'.join(s)               # 和其他方法不一样,请注意
3 print(s2)                       #s*u*m*m*e*r

⑪repalce(): 替换,可设置替换次数     *****

s = '我的老家在东北,东北有很多人'

默认是全文替换

1 s = '我的英文名叫夏天,因为夏天总是那么阳光明媚'
2 s1 = s.replace('夏天', '春天')
3 print(s1)

替换一次

1 s = '我的英文名叫夏天,因为夏天总是那么阳光明媚'
2 s1 = s.replace('夏天', '春天',1)
3 print(s1)                                           # 我的英文名叫春天,因为夏天总是那么阳光明媚

替换,是从左至右的 . 如果想要替换中间某部分,需要用到正则表达式

⑫ 格式化输出  format()

第一种用法: {}表示一个占位符

1 s = '我叫{},今年{},爱好{}'.format('summer', 18, '滑雪')
2 print(s)                                    # 我叫summer,今年18,爱好滑雪

第二种用法:

比如某个变量 出现了几十次,那么可以直接用个{索引}表示 ,修改format后面的参数,就可以生效了

1 s = '我叫{0},今年{1},爱好{2},即便是81岁我依然叫爱{2}'.format('summer', 18, '滑雪')
2 print(s)                    # 我叫summer,今年18,爱好滑雪,即便是81岁我依然叫爱滑雪

{2} 表示索引值,如果使用这种方式,索引值必须指定,否则报错

第三种用法: 键值对

1 s = '我叫{name},今年{age},爱好{hobby}'.format(age=18, name='summer', hobby='滑雪')
2 print(s)                    # 我叫summer,今年18,爱好滑雪
1 s1 = '我叫{},今年{},性别{}'.format('summer', '18', '女')
2 s2 = '我叫{0},今年{1},性别{2},我依然叫{0}'.format('summeri', '18', '女')
3 s3 = '我叫{name},今年{age},性别{sex}'.format(name='summer', sex='女', age='18')

⑬is 系列,返回bool值

1 name='summer123'
2 print(name.isalnum())         #判断是否是数字或字母组成
3 print(name.isdigit())         #判断是否是数字组成
4 print(name.isalpha())         #判断是否是字母组成

isdigit()比较常用,比如判断用户输入的,是否是数字。

或者将字符串转换为数字类型时,要判断字符串是否由纯数字组成,否则报错。

1 name = '123a'
2 if name.isdigit():
3     name = int(name)
4 else:
5     print('您输入的含有非数字元素')

执行输出:您输入的含有非数字元素

⑭公共方法:count()

1 name = 'summer'
2 print(name.count('m'))        # 统计a出现的次数 2
3 print(len(name))            # 查看数据的长度 6

四、 列表

列表是python中的基础数据类型之一,它是以[]括起来,每个元素以逗号隔开,而且他 里面可以存放各种数据类型 。比如:

li = [‘a’, 123, Ture, (1,2,3,’b’), [1,2,3,’小明’,], {‘name’:’summer’}]

列表相比于字符串,不仅可以储存不同的数据类型,而且可以储存大量数据。 列表是有序的

索引,切片,步长

列表的索引与字符串相同,都是索引、切片、步长

 1 li = ['xiao',123,True,(1,2,3,'a'),[1,2,3,'小明',],{'name':'xiao'}]
 2 print(li[0])
 3 print(li[2])
 4 print(li[1:4])
 5 print(li[:5:2])
 6 print(li[-1:-3:-1]) # 倒着取,后2个
输出结果:
xiao
True
[123, True, (1, 2, 3, 'a')]
['xiao', True, [1, 2, 3, '小明']]
[{'name': 'xiao'}, [1, 2, 3, '小明']]

列表的增、删、改、查

①append():在列表的最后追加,没有返回值

②insert():根据位置增加

③extend():在列表的最后追加,按照最小单元形式

append()追加,在最后一个位置添加元素

1 li = [1,'a','b',2,3,'a','lao']
2 li.append('xiao')
3 print(li) # [1, 'a', 'b', 2, 3, 'a', 'lao', 'xiao']
1 l1 =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 l1.append([1 ,2 ,3])
3 
4 # print(l1.append([1,2,3]))           #没有返回值,因为l1.append([1,2,3])是一个过程
5 
6 print(l1)                     # ['spring', 'summer', 'autumn', 'winter', [1, 2, 3]]

insert()按照索引添加

将元素插入到指定的索引值位置,后面的元素索引值会自动加1

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li.insert(2,'zhang') # 先索引,后内容
3 print(li) # ['spring', 'summer', 'zhang', 'autumn', 'winter']

extend()迭代着添加

在最后的位置,迭代每一个元素,依次添加。

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li.extend('ABC')
3 print(li) # ['spring', 'summer', 'autumn', 'winter', 'A', 'B', 'C']

使用输入框方式添加元素

 1 name_list =['spring' ,'summer' ,'autumn' ,'winter' ,]
 2 
 3 while True:
 4     name = input('请输入新员工姓名:Q/q ').strip()
 5     if name.upper() == 'Q':
 6         break
 7     else:
 8         name_list.append(name)
 9 
10         print('已成功添加新员工%s' % name)
11 
12 print(name_list)

1) pop():按照索引的位置删除,有返回值,返回值是被删除的元素

2) remove():按照元素删除

3) clear():清空

4) del[ ]:按照索引的位置删除 #  中括号,和其他不一样

按照切片和步长删除

全部清空

pop()按照索引删除

#默认删除最后一个

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li.pop()
3 print(li)           #['spring', 'summer', 'autumn']

#删除索引值为1的元素

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li.pop(1)
3 print(li)           #['spring', 'autumn', 'winter']

pop() 是增删改查所有方法里面,唯一有返回值的方法。返回删除的元素。pop()只能删除一个元素

remove()按照元素删除,只能删除一个

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li.remove('summer')
3 print(li)           #['spring', 'autumn', 'winter']

clear() 清空列表的所有元素

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li.clear()
3 print(li)           #[]

d el     删除列表

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 del li

# 按索引删除

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 del li[0]
3 print(li)           # ['summer', 'autumn', 'winter']

# 按 切片删除

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 del li[:3]
3 print(li)           # ['winter']

# 按照切片+步长删除

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 del li[::2]
3 print(li)           # ['summer', 'winter']

# 跳着删除

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 del li[:3:2]
3 print(li)           # ['summer', 'winter']

1) 按索引更改

2) 按切片更改:可在切片位置放任意多个参数

3) 按切片加步长更改:只能按照切片宽度放置参数个数

使用赋值修改

# 按索引更改,一次只能更改一处

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li[0] = 'abc'
3 print(li)           # ['abc', 'summer', 'autumn', 'winter']

# 按切片更改

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li[:4]=[11,22,33,44,55,66]
3 print(li)           # [11, 22, 33, 44, 55, 66]

#按切片加步长更改

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 li[:4:2]=[11,22]
3 print(li)           # [11, 'summer', 22, 'winter']

切片修改的执行过程是,先删除切片部分,再迭代添加的对象,依次添加元素。

1) 按照索引查;

2) 用for循环

for 循环

1 li =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 for i in li:
3     print(i)

其他操作方法:

列表可以相加

1 l1 =['spring' ,'summer' ,'autumn' ,'winter' ,]
2 l2=[1,2,3]
3 l3=l1+l2
4 
5 print(l3)           # ['spring', 'summer', 'autumn', 'winter', 1, 2, 3] 

② 在循环一个列表时,删除列表中的某一元素时,该元素后面的元素都会向前进一位,后面元素的索引会改变。所以 在循环一个列表时,最好不 对列表进行改变大小的操作(增和删)

例题:将列表中索引为奇数的元素删除

方法1:将列表中索引为偶数的元素加入到一个新的列表中

方法2:从列表后面开始删除

方法3:切片

l1=[11,22,33,44,55,66,77,88]

方法一

使用新列表覆盖

 1 l2 = []
 2 
 3 for i in range(len(l1)):
 4     if i % 2 == 0:
 5         l2.append(l1[i])
 6 
 7 li = l2
 8 print(li)

方法二

1 for i in range(len(l1),-1,-1):
2     if i % 2 == 1:
3         l1.pop(i)
4 
5 print(l1)

倒序删除

1 for i in range(len(l1)-1,-1,-1):
2     if i % 2 == 1:
3         del l1[i]
4 
5 print(l1)

方法三

1 l3 = l1[::2]
2 print(l3)
1 del l1[1::2]
2 print(li)

sort() 

# 从小到大,正向排序

1 li = [1,2,7,8,5,6,3,4]
2 li.sort()
3 
4 print(li)           # [1, 2, 3, 4, 5, 6, 7, 8]

# 从大到小,反向排序

1 li = [1,2,7,8,5,6,3,4]
2 li.sort(reverse=True)
3 
4 print(li)           # [8, 7, 6, 5, 4, 3, 2, 1]

reverse()翻转

翻转,就是将右边的元素和左边的元素进行对换。

1 li = [1,2,7,8,5,6,3,4]
2 li.reverse()
3 print(li)          # [4, 3, 6, 5, 8, 7, 2, 1]

任何排序都不如sort和reverse 快 , 如果没有明确要求指定排序方法,优先使用sort和reverse

len()查看数据长度

1 li = [1,2,7,8,5,6,3,4]
2 print(len(li))         # 8

count()统计元素出现次数

1 li = [1,2,7,8,5,6,3,4]
2 print(li.count(7))         # 1

index()通过元素找索引

1 li = [1,'a','b','a',2,3,'a']
2 print(li.index('a'))       # 1        

列表的嵌套 注意重新赋值

li = [1,2,'summer',['100','spring',99],22]

1.将summer 变成首字母大写的Summer
li[2] = li[2].capitalize()

2.将spring变成全部大写的SPRING放到原处
li[3][1] = li[3][1].upper()

3.将99加1变成100,返回原处
#数值加1
li[3][2] += 1
print(li)    

思考题: 将列表中的每一个元素打印出来,如果遇到列表,需要打印列表中的每一个元素    *****

答案:

li = [1, 2, ['spring' ,'summer' ,'autumn' ,'winter'], 'a', 'b']
for i in li:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)
输出结果:
1
2
spring
summer
autumn
winter
a
b

如果列表包含字典以及元组呢? li = [1,2,['alex','wusir'],'a','b',{'name':'xiao','age':21},('d','n','f')]

1 种写法*****

 1 li = [1, 2, ['spring' ,'summer' ,'autumn' ,'winter'], 'a', 'b']
 2 for i in li:
 3     #判断元素类型是否是整形和布尔值,除了这2种类型,其他类型都是可迭代对象
 4     if type(i) not in [int,bool]:
 5         # 判断元素的长度等于1,排除有多个元素的数据,比如列表,字典...
 6         if len(i) == 1:
 7             print(i)
 8         else:
 9             #循环可迭代对象
10             for j in i:
11                 print(j)
12     else:
13         print(i)

第2种写法 :    *****

 1 #加载模块
 2 from collections import Iterable
 3 
 4 li = [1, 2, ['spring' ,'summer' ,'autumn' ,'winter'], 'a', 'b']
 5 for i in li:
 6     #判断是否是可迭代对象
 7     if isinstance(i,Iterable):
 8         for j in i:
 9             print(j)
10     else:
11         print(i)

执行程序,效果同上

、元组tupe

元组被称为 只读列表 ,即数据 可以被查询,但不能被修改 .

1、查询方式:与列表相同

2、可使用公用方法index、count、len

3、应用场景:一些非常重要的数据不允许任何人修改就放在元组种。

4、元组的儿子不能修改,但是孙子可以修改

如果一个元组只由一个数据组成,且没有逗号,那么该“元组”的数据类型就是该数据的数据类型

 1 tu1 = (1)
 2 tu2 = ("hello")
 3 tu3 = ([1,2,3])
 4 tu4 = ({1:1,2:2})   
 5 
 6 print(type(tu1))    #<class 'int'>
 7 print(type(tu2))    #<class 'str'>
 8 print(type(tu3))    #<class 'list'>
 9 print(type(tu4))    #<class 'dict'>
10 
11 tu5 = (1,)           #有逗号,还是元组类型
12 print(type(tu5))    #<class 'tuple'>

字符串的切片操作同样适用于元组

1 tu = ('spring' ,'summer' ,'autumn' ,'winter')
2 print(tu[:2])              # ('spring', 'summer')
3 print(tu[2])               # 指定索引取值 autumn

遍历元祖

1 tu = ('spring' ,'summer' ,'autumn' ,'winter')
2 for i in tu:
3     print(i)

有一种情况,元组的值会改变,俗称: 儿子不能改,孙子可能改

1 tul1 = ('spring' ,'summer' ,['hot', 99, 'cool'],'autumn' ,'winter')
2 
3 # tul1[0] = 'namsahn'            # 元组里儿子不允许修改,会报错
4 tul1[2][0] = 123                # 元组里的孙子辈可以增删改
5 tul1[2].append('a')
6 
7 print(tul1)             # ('spring', 'summer', [123, 99, 'cool', 'a'], 'autumn', 'winter')

一般元组,是放只读的数据。所以不会随意更改。元组是只读列表,只允许查询,不允许增、删、改

元组转换为列表

1 tu = (1,2,3)
2 li = list(tu)
3 print(li)         # [1, 2, 3]

列表转换为元组

1 tu = [1,2,3]
2 li = tuple(tu)
3 print(li)       # (1, 2, 3)

字符串直接转换为元组是没有方法的。除非把字符串转换为列表,再转换为元组

、字典

字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。

字典使用 二分查找 . 二分查找也称折半查找(Binary Search) ,它是一种效率较高的查找方法。比如字典有1~100的数据,现在想要查找75。先劈一半,找到中间值50。判断50和75的大小,发现小于,再劈一半。找到中间值75,直接返回结果。

数据类型的分类:

可变数据类型(不可哈希):list,dict,set

不可变数据类型(可哈希):int,bool,str,tuple

容器类型:

容器类(承载各种数据类型):list,tuple,dic

字典的键:必须是不可变数据类型 字典的值:任意数据类型 字典的键是唯一的。

例如:

dic = {'name_list': ['王双', 'alex', '孙飞', 'taibai'],
       1: {'name': 'taibai', 'age': 18, 'sex': '男'},
       (1, 2): [100, {'ip': '192.168.1.1', 'port': 3306}]
       }

字典的顺序:严格意义上来讲,是无序的。 3.5之前,字典是无序的。3.6开始,字典创建的时候,按照一定的顺序插入的值,看起来是有序的

1、创建字典的三种方式:

① dic = {}

② dic = dict( {   } )

 dic.fromkeys(可迭代对象,value) ,value会被赋值可迭代对象里的每一个值

1 dic = dict.fromkeys('abc','alex')
2 print(dic)        # {'c': 'alex', 'b': 'alex', 'a': 'alex'}
3 
4 使用列表创建一个新字典
5 dic = dict.fromkeys([1,2,3],[])
6 print(dic)        # {1: [], 2: [], 3: []}

字典的第一个坑

给列表1添加一个元素

1 dic = dict.fromkeys([1,2,3],[])
2 dic[1].append('北京')
3 print(dic)                  # {1: ['北京'], 2: ['北京'], 3: ['北京']}

坑就来了,这3个列表,在内存中对应的是同一个列表

字典的第二个坑 在循环一个字典时,对字典的键值对进行删除会报错。

将字典中含有K元素的键,对应的键值对删除

dic = {'k1':'value1','k2':'value2','name':'summer'}

正常思路的写法:

 1 dic = {'k1':'value1','k2':'value2','name':'summer'}
 2 
 3 for i in dic.keys():
 4     if 'k' in i:
 5         dic.pop(i)
 6 
 7 print(dic)

  执行报错:RuntimeError: dictionary changed size during iteration

意思就是,在循环字典过程中,不允许改变字典

换一种思路,在字典中追加:

1 dic = {'k1':'value1','k2':'value2','name':'summer'}
2 count = 0
3 
4 for i in dic:
5     dic[i+str(count)] = dic[i]
6     count +=1
7 
8 print(dic)               # 执行报错,效果同上。        

这题应该这么做, 先将含有k的键值对,添加到列表 然后循环列表,删除字典的Key *****

 1 dic = {'k1':'value1','k2':'value2','name':'summer'}
 2 
 3 li = []
 4 for i in dic:
 5     if 'k' in i:
 6         li.append(i)
 7 
 8 for i in li:
 9     dic.pop(i)
10  
11 print(dic)    #{'name': 'wusir'}

总结:在循环列表或者字典的时候,千万不要做添加或者删除操作。

2 字典的增删改查

第一种: 用key进行定位,用=进行重新赋值 :字典中不存在这个key时,增加这个key到字典中,字典中本来就存在这个key时,就修改这个key对应的value

1 dic = {'name': 'summer', 'age': 21}
2 dic['hobby'] = 'skiing'
3 print(dic)          # {'age': 21, 'hobby': 'skiing', 'name': 'summer'}

第二种:  setdefault(key,value): 无则添加,有则不变

v alue可以省略,默认添加None。

1 dic = {'name': 'summer', 'age': 21}
2 dic.setdefault('hobby')
3 print(dic)          # {{'name': 'summer', 'age': 21, 'hobby': None}

添加键值对

1 dic = {'name': 'summer', 'age': 21}
2 dic.setdefault('hobby','skiing')
3 print(dic)          # {'name': 'summer', 'age': 21, 'hobby': 'skiing'}

添加一个已经存在的key

1 dic = {'name': 'summer', 'age': 21}
2 dic.setdefault('name','spring')
3 print(dic)          # {'name': 'summer', 'age': 21}

上述2个添加的方法,只能一个个添加。

1) pop() 删除指定的key。pop()是所有方法中,唯一有返回值的。

删除指定的key

dic = {'name': 'summer', 'age': 21}
print(dic.pop('age'))           # 21
print(dic)          # {'name': 'summer'}

删除一个不存在的key

1 dic = {'name': 'summer', 'age': 21}
2 print(dic.pop('hobby'))
3 print(dic)          # 报错KeyError: 'hobby'

删除一个不存在的key,并指定默认返回值None

1 dic = {'name': 'summer', 'age': 21}
2 print(dic.pop('hobby',None)) # None
3 print(dic)          # {'name': 'summer', 'age': 21}

推荐使用上述方法,删除一个key。因为如果key不存在时,不会报错,返回None。程序员最怕报错了!

2) clear() 清空

1 dic = {'name': 'summer', 'age': 21}
2 dic.clear()
3 print(dic)          # {}

3)del 删除字典

按照键删除,del dic[' key '] 。如果不存在,会报错

1 dic = {'name': 'summer', 'age': 21}
2 del dic['hobby']

从内存上清空 del dic

1 dic = {'name': 'summer', 'age': 21}
2 del dic
3 print(dic)          # NameError: name 'dic' is not defined

4) popitem() 随机删除,有返回值.

  在python3.6之前,随机删除一个键值对;从python3.6开始,删除最后一个键值对

1 dic = {'name': 'summer', 'age': 21}
2 print(dic.popitem()) # ('age', 21)
3 print(dic)          # {'name': 'summer'}

1) 通过键和=进行修改,与增的用法相同

1 dic = {'name': 'summer', 'age': 21}
2 dic['name'] = 'zhangsan'
3 print(dic)          # {'name': 'zhangsan', 'age': 21}

2)update():

dic1.update(dic2):将dic2中的所有键值对覆盖并添加到dic1中(键相同的覆盖,键不同的添加)

1 # 针对2个字典的修改
2 dic1 = {'name': 'summer', 'age': 21}
3 dic2 = {'name': 'spring', 'hobby': 'skiing'}
4 
5 # 将dic键值对,覆盖并添加到dic2
6 dic1.update(dic2)
7 print(dic1)  # {'name': 'spring', 'age': 21, 'hobby': 'skiing'}
8 print(dic2)  # {'name': 'spring', 'hobby': 'skiing'}

可以发现dic2没有改变,dic1改变了.  update()修改原则 , 有相同的就覆盖,没有的就添加

1) 通过key进行查找(与列表通过索引进行查询相似)

1 dic = {'name':'summer','age':21}
2 print(dic['name'])     
1 通过value查询
2 
3 dic = {'name':'summer','age':21}
4 print(dic['summer']) # 执行报错: KeyError: 'xiao'

字典只能通过key查询,不能通过value查询,否则报错

2)    get(k,None):字典种有这个key的返回这个key对应的value,没有的话返回第二参数,第二参数可以不写,默认返回None

#有这个key,返回这个key对应的value值

dic = {'name': 'summer', 'age': 21}
print(dic.get('name'))                  # summer

# 查询一个不存在的key , 默认返回None

1 dic = {'name': 'summer', 'age': 21}
2 print(dic.get('hobby'))             # None

查询一个不存在的key , 设置返回值

1 dic = {'name': 'summer', 'age': 21}
2 print(dic.get('hobby','亲,木有这个字哦!')) # 亲,木有这个字哦!

# 如果需要查询多个key,请使用for循环

1 dic = {'name': 'summer', 'age': 21}
2 for i in dic:
3     print(i)
执行输出:
age
Name

3. 字典的特殊使用方法 .keys() .values() .items()

1)  dic.keys(   )

用于提取字典种的key值,返回值的类型是 dict_keys

1 dic = {'name':'helen','age':18,'sex':'women'}
2 print(dic.keys(),type(dic.keys()))   # dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>

提取字典中的key值,并将其转化为列表 list(dic.keys())

1 dic = {'name':'helen','age':18,'sex':'women'}
2 li = list(dic.keys())
3 
4 print(li)   # ['name', 'age', 'sex']

与for结合使用:输出的就是字典里的key( 按原来的数据类型

1 dic = {'name': 'summer', 'age': 21}
2 
3 for i in dic.keys():
4     print(i)
执行输出:
age
Name

keys()方法输出的数据是一个特殊类型,它相当于把所有的key放到了一个容器里面。它类似于列表的容器,当它并不是列表。

2)  dic.values()

① 用于提取字典种的value值,返回值的类型是 dict_values

1 dic = {'name':'helen','age':18,'sex':'women'}
2 print(dic.values(), type(dic.values()))    # dict_values(['helen', 18, 'women']) <class 'dict_values'>

② 提取字典中的value值,并将其转化为列表      list(dic.values())

1 dic = {'name':'helen','age':18,'sex':'women'}
2 li = list(dic.values())
3 print(li)         # ['helen', 18, 'women']

③ 与for结合使用:输出的就是字典里的value( 按原来的数据类型

1 dic = {'name':'helen','age':18,'sex':'women'}
2 
3 for i in dic.values():     
4     print(i)
输出结果是:
helen
18
Women

3)  dic.items()

① 用于提取字典种的key和value值,并将key和它对应的value用 元组 包围起来,返回值的类型是 dict_items

1 dic = {'name': 'helen', 'age': 18, 'sex': 'women'}
2 print(dic.items(), type(dic.items()))       # dict_items([('name', 'helen'), ('age', 18), ('sex', 'women')]) <class 'dict_items'>

② 提取字典中的key和value值,并将其转化为列表      list(dic.items()) ,其中key和它对应的value用元组包围起来[(key,value),(key,value),.....]

1 dic = {'name': 'helen', 'age': 18, 'sex': 'women'}
2 li = list(dic.items())
3 print(li)                   # [('name', 'helen'), ('age', 18), ('sex', 'women')]

③ 与for结合使用:输出的就是字典里的key和value(按原来的数据类型)

I. for k,v in dic.items()  : 输出原始格式的key和value

dic = {'name': 'helen', 'age': 18, 'sex': 'women'}

for k,v in dic.items():
    print(k,v)

输出结果
 name helen
 age 18
 sex women

II. for i in dic.items()    : 输出被元组包围的key和value

dic = {'name': 'helen', 'age': 18, 'sex': 'women'}

for i in dic.items():           
    print(i)   

输出结果
('name', 'helen')
('age', 18)
('sex', 'women')

III. for i in dic()     : 输出原始格式的key

dic = {'name': 'helen', 'age': 18, 'sex': 'women'}

for i in dic:
    print(i)

输出结果
 name
 age
 sex

4. 字典的嵌套

dic = {'name_list': ['王双', 'alex', '孙飞', 'taibai'],
       1: {'name': 'taibai', 'age': 18, 'sex': '男'},
       (1,2): [100, {'ip': '192.168.1.1', 'port': 3306}]
       }

1,给 name_list对应的列表追加一个值: 司徒大人.
dic['name_list'].append('司徒大人')
print(dic)

2,将name_lsit对应的alex 变成全部大写. # 注意重新赋值
dic['name_list'][1]=dic['name_list'][1].upper()
print(dic)

3, 将1对应的字典添加一个键值对: weight : 75
dic[1]['weight'] = 75
print(dic)

4,将1 对应的字典的name键对应的名字taibai 换成alex
dic[1]['name'] = 'alex'
print(dic)

5,将 {'ip': '192.168.1.1', 'port': 3306} 次字典的port键值对删除.
dic[(1,2)][1].pop('port')
print(dic)

七、 集合

set1 = {1,2,’summer‘,(3,4)}

集合里面的元素必须是不可变的,只能是数字、字符串、bool值、元组,但是集合本身是可变的数据类型,集合里面的元素不能重复,集合是无序的。

1. 集合的创建

set1 = {   }

set1 = set( {   } )

2.集合常用操作   增 删 查

add()

1 set1 = {'summer','spring'}
2 set1.add('winter')
3 print(set1) #  {'spring', 'summer', 'winter'}

update()   迭代的增加

1 set1 = {'summer','spring'}
2 set1.update('abc')
3 print(set1) #  {'c', 'b', 'summer', 'a', 'spring'}

pop()  随机删除 ,pop() 是有返回值的

1 set1 = {'summer','spring'}
2 print(set1.pop()) #  summer
3 print(set1) #  {{'spring'}

remove() 删除一个元素

1 set1 = {'summer','spring'}
2 set1.remove('summer')
3 print(set1) #  {{'spring'}

clear() 清空集合

1 set1 = {'summer','spring'}
2 set1.clear()
3 print(set1) # set()

del 删除集合

1 set1 = {'summer','spring'}
2 del set1
3 print(set1) # NameError: name 'set1' is not defined

集合无改的方法

查只能for循环

1 set1 = {'summer','spring'}
2 for i in set1:
3     print(i)

3. 集合作用

1) 列表去重 :直接转换为集合,就可以

1 li = [11,11,22,22,33,33,33,44]
2 li = list(set(li))
3 
4 print(li)     # [33, 11, 44, 22]            

2)关系测试

交集( &或者intersection)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 & set2)
print(set1.intersection(set2))

 
执行输出:
{4, 5}
{4, 5}

并集( |或union)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 | set2)
print(set1.union(set2))


执行输出:
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}

反交集( ^或 symmetric_difference) 和交集,取反的结果,也就是说,删除相同的,保留不同的。

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 ^ set2)
print(set1.symmetric_difference(set2))


执行输出:
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}

差集( - 或difference)

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}

print(set1 - set2)
print(set1.difference(set2))

 
执行输出:
{1, 2, 3}
{1, 2, 3}

子集(issubset)

判断一个集合是否被另外一个集合包含

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1.issubset(set2))       # True

超集(issuperset)

判断一个集合是否包含另外一个集合

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set2.issuperset(set1)) # True

集合关系测试,记符合就可以了,英文字母太长了,不好记。

frozenset()将集合转换为可哈希的类型,可以作为字典的key

set1 = {'summer','spring'}
set2 = frozenset(set1)

print(set2) # frozenset({'summer', 'spring'})
原文  http://www.cnblogs.com/Summer-skr--blog/p/11469191.html
正文到此结束
Loading...