基础"/>
数据分析Python基础
数据分析Python基础
文章内容输出来源:拉钩教育数据分析训练营–直达飞机票(想了解的小伙伴)
本人为传统行业ETL,想转行数据分析,感觉自学有点困难,之前偶然接触到拉钩教育中的1元文章,都是各领域大佬的手笔,内容质量很高,刚好拉钩也有数据分析的训练营,看了看课程安排,简单咨询了下,就报名了,现在学到了数据挖掘部分,感觉Python基础的内容有些都忘了,所以特意巩固下,才写的这篇文章
目录
- 数据分析Python基础
- Python数据结构
- 1.序列
- 1.1 不可变序列
- 1.11 元组(tuple)
- <font size = 3>①什么是元组?
- <font size = 3>②元组的创建
- <font size = 3>③元组的CRUD
- <font size = 3>④元组的遍历
- <font size = 3>⑤元组的常用函数
- <font size = 3>⑥练习
- 1.12 字符串(str)
- <font size = 3>①什么是字符串?
- <font size = 3>②字符串的创建
- <font size = 3>③常用函数及操作
- <font size = 3>⑥练习
- 1.2 可变序列
- 1.21 列表(list)
- <font size = 3>①什么是列表?
- <font size = 3>②列表的创建
- <font size = 3>③列表的CRUD
- <font size = 3>④列表的遍历
- <font size = 3>⑤常用函数
- <font size = 3>⑥列表推导式
- <font size = 3>⑦练习
- 1.3 其他对象
- 1.31 集合
- <font size = 3>①什么是集合?
- <font size = 3>②集合的创建
- <font size = 3>③集合的CRUD
- <font size = 3>④集合的遍历
- <font size = 3>⑤常用函数
- 1.32 字典
- <font size = 3>①什么是字典?
- <font size = 3>②字典的创建
- <font size = 3>③字典的CRUD
- <font size = 3>④字典的遍历
- <font size = 3>⑤常用函数
提示：以下是本篇文章正文内容，下面案例可供参考
Python数据结构
1.序列
序列是Python中最基本的一种数据结构,指的是一个可迭代的有序的集合,序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置(通过index访问),并且序列中的数据会按照添加的顺序来分配索引,然而通过序列中元素是否可以改变又分为可变序列和不可变序列.
1.1 不可变序列
1.11 元组(tuple)
①什么是元组?
元组是一种不可变的序列,正是由于元组的对象不可变性,所以没有增删改操作,元组中可以存储不同类型的对象.
②元组的创建
操作如下:
1.使用()来创建元组
my_tup = () # 创建了一个空元组
print(my_tuple,type(my_tuple))
# result: () <class 'tuple'>
my_tuple = (1,2,3,4,5) # 创建了一个5个元素的元组
print(my_tuple,type(my_tuple))
# result: (1, 2, 3, 4, 5) <class 'tuple'>
2.元组是不可变对象，不能尝试为元组中的元素重新赋值
my_tuple[3] = 10 #注:体现了元组元素一旦添加不可修改
# result: TypeError: 'tuple' object does not support item assignment
3.当元组不是空元组时，括号可以省略
my_tuple = 5,2,0
print(my_tuple,type(my_tuple))
# result: (5, 2, 0) <class 'tuple'>
#注意但当元组中只有一个元素时候必须在元素后加个',',否则识别为原元素的数据类型(加不加括号都可以)
my_typle =(40)
type(my_typle)
# result: int 注:结果为int类型,也就是40的类型
#正确写法
my_tuple = 40, #等价于my_tuple = (40,)
type(my_typle)
# result: tuple 注:此时的my_tuple才是真正的元组
4.元组的解包（解构）
# 解包可以理解为就是将元组当中每一个元素都赋值给一个变量
my_typle = 4,False,28,'a'
a,b,c,d = my_tuple
print(a,b,c,d)
# result: 4 False 28 a
5.交互a 和 b的值，这时我们就可以利用元组的解包(相当方便)
#交换前
a = 5
b = 8
print(a,b)
# result: 5 8
a , b = b , a
#交换后
print(a , b)
# result:8 5
6.在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致
my_tuple = 10 , 20 , 30 , 40
m,n,x,y = my_tuple
print(m,n,x,y)
# result: 10 20 30 40
# 也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素
my_tuple = 1,2,3,4,5,6
a , b , *c = my_tuple
print(a,b,c)
#result: 1 2 [3, 4, 5, 6] 注:[3, 4, 5, 6] 部分为列表(list)后面会讲到
a , *b , c = my_tuple
print(a,b,c)
# result: 1 [2, 3, 4, 5] 6
a , b , *c = 'hello world'
print(a,b,c)
# result: h e ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
# 不能同时出现两个或以上的*变量
*a , *b , c = 'hello world' #两个'*'导致系统不会分配了,怕分不均打起来,它也是个老好人...
# result: SyntaxError: two starred expressions in assignmenta 注:结果报错
③元组的CRUD
(由于元组中元素不可变,所以就没有增删改操作,只有查询操作)
1.前面提到元组属于序列,序列的通性就有可以通过索引来访问序列中的元素(tuple,list,str)后面会陆续讲到,而且第一个元素的索引为0,最后一个元素索引为-1
my_tuple = (1,'str',False,7.8,None)
print(my_tuple[3],my_tuple[0]) #访问元组中第一个元素和第四个元素
# result: 7.8 1
# 访问最后一个元素
print(my_tuple[-1])
# result: None
2.突然想呼应下元组元素不可修改,真的吗?有'bug'? come to see see
my_tuple = (1,[2,'str',False],'hello')
#操作1
my_tuple[0] = 'wahaha' #哦哦!第一个元素的确不可修改
# result: 'tuple' object does not support item assignment
#操作2
my_tuple[1][0] = 'bug'
print(my_tuple)
# result: (1, ['bug', 'str', False], 'hello') 注:what fu** ? 啥子情况哟?说好一百年不许变呢?
#看一下 my_tuple 中第二个元素[2,'str',False] 在修改前后变化
my_tuple = (1,[2,'str',False],'hello')
#修改前:id()函数:打印对象在内存中的地址,id值相同就为同一个对象
print(my_tuple,type(my_tuple[1]),id(my_tuple[1]))
# result: (1, [2, 'str', False], 'hello') <class 'list'> 2595153146560
#修改后:
my_tuple[1][0] = 'bug'
print(my_tuple,type(my_tuple[1]),id(my_tuple[1]))
# result:(1, ['bug', 'str', False], 'hello') <class 'list'> 2595153146560
'''可以看出my_tuple的第一个元素(也就是[]整体)的地址2595153146560是没变的,变化的是元素中的元素变了,这是由于[2, 'str', False]是列表,my_tuple[1][0] = 'bug'操作是将列表[2, 'str', False]中的第一个元素2给修改成了'bug',而list本身是可变的,也就是list修改元素后,原list的地址是不变的,所以再回到元组中
元素不可变的说法是没问题的'''
#也可以如下尝试,尝试将[2,'str',False]整体进行修改
my_tuple[1] = 'bug' #再次验证tuple的元素不可变
# result: 'tuple' object does not support item assignment
④元组的遍历
什么是遍历?
个人理解为就是将对象中所有元素都拿出来瞧瞧
#遍历元组
1.方式一:for
my_tuple = ('a',True,None,1.0,5)
for i in my_tuple:print(i, end = ' ') #注:print(end=' ')将末尾默认字符修改为空格,默认为换行符
# result: a True None 1.0 5 注:遍历就是将元组中所有元素获取一遍 2.方式二: while
my_tuple = ('a',True,None,1.0,5)
i = 0
while i < len(my_tuple): #相当于java中lengthprint(my_tuple[i],end=' ')i+=1
# result: a True None 1.0 5 3.方式三:range()
my_tuple = ('a',True,None,1.0,5)
for i in range(len(my_tuple)):print(my_tuple[i],end=' ')i+=1
# result : a True None 1.0 5 注意:熟练一种即可(哪个舒服就用哪个)
⑤元组的常用函数
说明:如何查看对象的自带方法(dir)有哪些以及方法如何使用(help)
1.查看对象拥有哪些自带方法(dir)
dir(tuple) --查看元组有哪些自带方法(查看其他对象同理)
''' result: ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__',
'__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
注:我是小白,所以也就关注前后不带'_'的方法玩一玩了,这一看就剩count,和index方法了 '''
2.每个方法如何使用(help)
这里以元组的count()方法为例
help(tuple.count) #查看元组的count方法如何使用(以后学习一个新方法时使用)
# result: Help on method_descriptor:
#count(self, value, /) 注:简单看就是查看目标字符在对象中的个数
# Return number of occurrences of value.
下面介绍下这两个方法的使用
1)count():统计出现次数
my_tuple = ('a','b','c','c','c','a',1,1,2)
print(my_tuple.count('a'))
# result: 2 注:元组中有2个'a'
my_tuple.count(1)
# result: 2 注:元组中有2个1
2)index():查询元素第一次出现的位置,脾气暴躁(找不到就生气)
my_tuple = ('a','b','c','c','c','a',1,1,2)
my_tuple.index('b')
# result: 1 注:字符'b'第一次出现的索引为1
print(my_tuple.index(1))
# result: 6 注:数字1第一次出现的索引为6(虽然7位置也有1但是结果为第一次的位置)
#找不到就生气()报错
my_tuple = ('a','b','c','c','c','a',1,1,2)
my_tuple.index('lagou')
# result: ValueError: tuple.index(x): x not in tuple 注:当前元组没有此元素
3) in /not in 判断元组中是否包含某个元素
my_tuple = ('a','b','c','c','c','a',1,1,2)
'a' in my_tuple
# result: True
'lagou' in my_tuple
# result: False
'lagou' not in my_tuple
# result: True
4)sum(),如果元组中元素都为int或float,可以sum()直接求和 注:sum()为python自带函数
my_tuple = 1,2,3,4,5,3.7
sum(my_tuple)
# result: 18.7
⑥练习
说明,sales中每个元组为一个销售员的姓名以及第一季度(1,2,3月)的业绩
需求:求出一季度销冠(名字以及一季度业绩)
sales = (("Peter", (78, 70, 65)),("John", (88, 80, 85)),("Tony", (90, 99, 95)),("Henry", (80, 70, 55)),("Mike", (95, 90, 95))
)
#1.精简前
champion = '' #销冠名字初始化为''
max = 0 #一季度最高销售额,初始化为0
for sale in sales: #遍历name = sale[0] #取出名字quarter = sale[1] #取出一季度(1,2,3月)业绩quarter_sales = 0 #季度总销售额for month_sales in quarter: #遍历每个人的一季度每个月的业绩quarter_sales += month_sales #对一季度每个月业绩加和if quarter_sales > max: #将所有销售员季度总和算出取最大的champion = name #销冠姓名max = quarter_sales #销冠季度业绩
print('第一季度的销售冠军是{0},总销售额为{1}万元'.format(champion,max))
# result: 第一季度的销售冠军是Tony,总销售额为284万元# 2.精简后,简直不要太爽(代码精简)
champion = ''
max = 0
for name,quarter in sales: #这种写法可以回想元组的解包,("Peter", (78, 70, 65))中的Perter 赋值给name,(78, 70, 65)赋值给quartertotal = sum(quarter) #直接将一季度业绩(78, 70, 65)求和if total > max:max,champion = total,name #解包赋值
print('第一季度的销售冠军是{0},总销售额为{1}万元'.format(champion,max))
# result: 第一季度的销售冠军是Tony,总销售额为284万元
1.12 字符串(str)
①什么是字符串?
字符串其实也是一种序列，可以理解为一串整齐的按顺序排着队的字符，组成了字符串，那每个字符在队伍中都有自己的位置，这个位置就是下标，又叫作索引。
②字符串的创建
还记得学习Python运行的第一个程序,也是学习每种编程语言的第一个程序,对,没错,打印hello world! 它就是个字符串.
操作如下:
1.创建字符串(用单引号''或者双引号""都可以,没什么区别)
my_str = 'I love Python'
print(my_str,type(my_str))
# result: I love Python <class 'str'>
my_str1 = "good good study"
print(my_str1,type(my_str1)) #看个人习惯,我比较习惯单引号
# result: good good study <class 'str'>
2.三引号(将一大段内容原样输出) --来自某道翻译,不要见怪
motto = ''' #注三引号可以是单引号,也可以是双引号
Where there is a will there is a way,
burn one's Bridges,
the twelve Qin pass finally belongs to Chu;
Hard days,
three thousand more can swallow wu
'''
# result: print(motto) #原样输出
# Where there is a will there is a way,
# burn one's Bridges,
# the twelve Qin pass finally belongs to Chu;
# Hard days,
# three thousand more can swallow wu
3.有时候定义的字符串太长一行放不下,用'\'进行连接
story = 'this is a long long long long long \
story,a very very very ......' #虽然看着换行了但结果还是一行
print(story)
#result: this is a long long long long long story,a very very very ......
③常用函数及操作
1.字符串的格式化输出
1)格式化占位符
| 占位符 | 描述 |
|---|---|
| %d | 整数占位符 |
| %f | 浮点数占位符 |
| %.f | 指定精度的浮点数占位符 |
| %s | 字符串占位符 |
| %% | 输出百分号% |
| 操作如下: |
1.%d (整数占位符)
print('北上广数据分析师的平均薪资为%dK'% 20) 注:后面%后的20在输出时就替代了前面的%d,使得输出更加灵活
# result: 北上广数据分析师的平均薪资为20K
如果给%d 传入一个浮点数，那它会自动将它转换成整数(截断而不是四舍五入)
print('%d' % 3.1415926)
# result: 3
print('%d' % 3.9999999)
# resutl: 3
2.%f(浮点数占位符)、%.f(指定精度的浮点数占位符)
1)%f
print('%f' % 3.14)
# result: 3.140000 自动补0
2)%.f 限定小数位数
print('%.2f' % 3.14)
# result: 3.14
print('%.2f' % 3.1415926)
# result: 3.14
print('%.4f' % 3.14)
# result: 3.1400
上面的两行代码输出都是"3.14"，"%.2f" 这种写法指定了小数点后面的位数，即使浮点数后面的小数部
分超出了2位,也只会输出两位。如果不足位,自动补零到两位,如第三个。
3.%s是使用最广泛的占位符，它可以对应任何类型的变量
print('%s' % 100)
# resutl: 100
print('%s' % 3.14)
# resutl: 3.14
print('%s' % "python")
# resutl: python
4.一个字符串中也可以出现多个占位符
report = '%d年%s公司营收增长了百分之%.2f' % (2088, "哆音", 28.28)
print(report)
# result: 2088年哆音公司营收增长了百分之20.28
5.%% 输出百分号%
report = '%d年%s公司营收增长了%.2f%%' % (2088, "哆音", 28.28)
print(report)
# result: 2088年哆音公司营收增长了28.28%
- format函数(实现%相同功能)
report = '{0}年{1}公司营收增长了{2}%'.format(2088, '哆音', 28.28)
print(report) #{0},{1},{2},三个参数分别对应(2088, '哆音', 28.28),
# 注意如果只要一个参数,{}中的数字必须为0--> {0)
# result: 2088年哆音公司营收增长了28.28%
#这样做的好处是如果有参数在字符串出现多次，可以不用重复的传入
#例如:
report = '{0}的GDP为{1}...虽然它的GDP只有{1}美元，但它的人均GDP高达18万美元'.format("摩纳哥",7100000000)
print(report)
# result: 摩纳哥的GDP为7100000000...虽然它的GDP只有7100000000美元，但它的人均GDP高达18万美元
2.字符串的索引及切片
1)字符串的索引(序列的索引都一样)
正向从0开始,反向从-1开始
操作如下:
1.通过索引访问各个字符
my_str = 'CHINA'
my_str[0] #访问第一个字符
# result: 'C'
my_str[-1] #访问最后一个字符
# result: 'A'
2.遍历
my_str1 = [ i for i in my_str] #遍历
# result: ['C', 'H', 'I', 'N', 'A']
#可以通过join方法将列表拼接回字符串
my_str2 = ''.join(my_str1) #通过''拼接
# result: 'CHINA'
2)字符串的切片(序列的特性)
字符串的切片是基于其索引特点,语法为 str[start :end :step ]
str[start:end:step] #参数说明 start:起始索引,end:结束索引,step:步长 注:[start,end),左闭右开区间
str1 = 'I LOVE CHINA'
str1[0:5:2]
# result: 'ILV'
str1[1:4] # 注:当只写一个':'时默认':'前后代表start和end,步长默认为1
# result: ' LO'
str1[:5] # 注:start缺省时默认从头开始(也就是0开始)
# result: 'I LOV'
str1[2:] #注:end缺省时默认一直取到字符串的最后一个字符
# result: 'LOVE CHINA'
str1[2:-1] # 取不到最后一个字符(左闭右开)
# result: 'LOVE CHIN'
str1[:] #或者str1[::] 结果一样 都是取整个字符串
# result: 'I LOVE CHINA'
#当step为负数可以理解为将字符串按从右向左取值
str1[::-2] #从右往左每隔一个取一个
# result: 'AICEO '
str1[::-1] #相当于逆序输入整个字符串
# result: 'ANIHC EVOL I'
3.字符串其他函数
1)去除空白字符函数(strip())
先来了解一下什么是空白字符，空白符包括空格、换行（\n）、制表符（\t）
print("A\tB C\nD\tE F")
# result: A B C
# D E F
#按键盘上的空格键会产生一个空格，按回车键则会产生一个换行符，按Tab键则会产生一个制表符，用户在输入数据的时候有时候经常会误输入这几个字符，
1.所以在在处理用户输入的数据时，要先去除头尾的空白字符。
psword = 'enterlagou'
input_psword = ' enterlagou' #手误密码前输入一个空格
print(psword == input_psword )
# result: False
此时就需要将空格去掉
psword = 'enterlagou'
input_psword = ' enterlagou' #手误密码前输入一个空格
print(psword == input_psword.strip()) #strip()函数将字符串的首尾空格去掉
# result: True
#例如:
str1 = ' good good study,day day up ' #首尾各一个空格
str2 = 'good good study,day day up'
print(str1==str2,str1.strip() == str2)
# result: False True
2.strip(),还有lstrip(),rstrip()分别表示从首部、尾去除空格
str1 = ' Cheer Up '
print(str1.lstrip(),'---',str1.rstrip())
# result: 'Cheer Up '---' Cheer Up'
2)字符串大小写
1.所有字符变大写(upper())
my_dream = 'I want to be the boss'
print(my_dream.upper())
# result: I WANT TO BE THE BOSS
2.所有字符变小写(lower())
my_dream = 'I want to be the boss'
print(my_dream.lower())
# result: i want to be the boss
3.字符串的首字母大写(capitalize())
str.capitalize('i am chinese')
# result: 'I am chinese'
4.字符串中每个单词首字母大写(title())
str.title('go to school by bus')
# result: 'Go To School By Bus'
3)字符串其他方法
1.startswith(value,start,end): 在[start,end)范围内,是否以指定的字符串开头
str1 = 'Lagou Education'
str1.startswith('Lagou ',0,-1)
# result: True
2.endswith(value,start,end) 在[start,end)范围内,是否以指定的字符串结尾
str1 = 'Lagou Education'
str1.endswith('ion')
# result: True
3.isdigit() 判断字符串中字符是否都是数字
'89757'.isdigit()
# result: True
4.isalpha() 判断字符串中字符是否都是英文字母(不分大小写)
'Thebestwaytosucceedistolearn'.isalpha()
# result: True
5.join() 将指定字符串与目标对象进行拼接,返回一个新字符串
'-'.join(['one','two','three'])
# result: 'one-two-three'
6.islower() 判断对象中字母是否为小写字母
't hebest-waytosucceedistolearn'.islower() #注意只对对象中的字母进行判断
# result: True
7.isupper() 判断对象中字母是否为大写字母
'T HEBEST-WAYTOSUCCEEDISTOLEARN'.isupper() #同样只对对象中的字母进行判断
# result: True
8.find(value,start,end) 在[start,end)区间中查找第一次出现的字符串的索引位置(查询不到返回-1)
'The best way to succeed is to learn'.find('succeed')
# result: 16
'The best way to succeed is to learn'.find('fail')
# result: -1 #查询不到返回-1
9.index(value,start,end) 在[start,end)区间中查找第一次出现的字符串的索引位置(查询不到报错)
'helloworld'.index('o')
# result: 4
'helloworld'.index('ab') #查询不要就报错
# result: ValueError: substring not found
10.count(value,start,end) 统计指定字符在对象中[start,end)区间出现的次数
'helloworld'.count('l')
# result: 3
11.replace(self, old, new, count) 在对象中将old值替换为new值,count 替换几次
'in a big big world'.replace('big','small',1) #将对象中big替换为small并且值替换一个
# result: 'in a small big world' 结果看出第二个big并没有被替换,count默认-1,替换所有old值
'in a big big world'.replace('big','small')
# result: 'in a small small world' 都被替换
12.split() 按指定字符拆分字符串 返回值结果为list类型
'Time will dilute everything'.split() #默认按空格进行拆分
# result: ['Time', 'will', 'dilute', 'everything']
'Time will dilute everything'.split('e') # 按'e'进行拆分
# result: ['Tim', ' will dilut', ' ', 'v', 'rything']
13.len() 计算对象的长度(系统函数)
#它不光可以测量字符串的长度，也可以测量其他所有有长度的对象
len('CHINA') #字符串有几个字符
# result: 5
len((1,'2','three')) #元组有几个元素
len([1,'2','three']) #列表有几个元素
len({1,'2','three'}) #集合有几个元素
len({'num':1,'id':'2','age':'three'}) #字典有几个键值对
# result: 3
14.in /not in 指定字符串在不在对象中
'lagou' in 'lagou Education'
# result: True
'Education' not in 'lagou Education'
# result: False
15.==/!= 判断两字符串元素是否完全相同
str1 = 'Real and fake Monkey King'
str2 = 'Real and fake Monkey King'
str1 == str2
# result: True
'True' != 'False'
# result: True
16.is / not is 是否是同一个对象(id值相同就是同一个对象)
str1 = 'Ilovepython'
str2 = 'Ilovepython'
print('值是否相等:{0},id值是否相等:{1},是否为同一对象:{2}'.format(str1==str2,id(str1)==id(str2),str1 is str2))
# result: 值是否相等:True,id值是否相等:True,是否为同一对象:True
# 注:发现字符串值相等的时候是同一个对象,回想下其他对象好像不是这样
#测试元组
tup1 = (1,2,3)
tup2 = (1,2,3)
print('值是否相等:{0},id值是否相等:{1},是否为同一对象:{2}'.format(tup1==tup2,id(tup1)==id(tup2),tup1 is tup2))
# result: 值是否相等:True,id值是否相等:False,是否为同一对象:False
#测试列表
lst1 = [1,2,3]
lst2 = [1,2,3]
print('值是否相等:{0},id值是否相等:{1},是否为同一对象:{2}'.format(lst1==lst2,id(lst1)==id(lst2),lst1 is lst2))
# result: 值是否相等:True,id值是否相等:False,是否为同一对象:False
#测试集合
set1 = {1,2,3}
set2 = {1,2,3}
print('值是否相等:{0},id值是否相等:{1},是否为同一对象:{2}'.format(set1==set2,id(set1)==id(set2),set1 is set2))
# result: 值是否相等:True,id值是否相等:False,是否为同一对象:False
#测试字典
dic1 = {1,2,3}
dic2 = {1,2,3}
print('值是否相等:{0},id值是否相等:{1},是否为同一对象:{2}'.format(dic1==dic2,id(dic1)==id(dic2),dic1 is dic2))
# result: 值是否相等:True,id值是否相等:False,是否为同一对象:False
发现元组,列表,集合,字典在元素值相同时不是一个对象,同时字符串相同元素时是同一对象是有前提的
例如:
str1 = 'I love python'
str2 = 'I love python'
print('值是否相等:{0},id值是否相等:{1},是否为同一对象:{2}'.format(str1==str2,id(str1)==id(str2),str1 is str2)) #发现此时元素相同又不是同一对象了
# result: # result: 值是否相等:True,id值是否相等:False,是否为同一对象:False
从一个公众号(数据分析与统计学之美公众号中)了解到
Python支持字符串驻留机制:也就是对于符合标识符的字符串(符合标识符:仅仅包含下划线,字母,数字),
才会启用字符串驻留机制,即不同的变量用同一份相同且不可变的字符串(打个比方:好比一家卖鞋的线下门店,
某种鞋子,41码大小的只剩下一双,所以就导致了所有想要试穿41码的这种鞋的顾客试的都是这一双鞋)
str1 = '_88level_' #符合标识符的字符串
str2 = '_88level_'
str1 is str2
# result: True
str1 = '_88level _' #不符合标识符的字符串(有个空格)
str2 = '_88level _'
str1 is str2
# result: False 不知道我是否表达明白了呢?
⑥练习
结合以上的字符操作知识，我们练习一个电话号码识别程序，用户输入一串数字，程序识别它是不是一个有效的电话号码，如果是有效电话号码，我们再识别它是一个固定电话号码、手机号码、还是400号码。用户输入’exit’后，程序退出.
已知:
手机号:前两位为 13,15,17,18,19 并且总位数为11位
固定电话:区号+号码,并且假设区号只有010、021、022、025、0888、0555这几种,号码为8位,也就是座机号总位数为11位或12位
广告电话:这个特征很明显，以400开头，共10位
实现代码如下：
cellphone_number_start = "13,15,17,18,19" #手机号
telephone_number_start = "010,021,022,025,0888,0555" #座机区号
while True:num = input("请输入一个电话号码: \n")num = num.strip() #首尾空格去掉if num.strip() == 'exit': breakif not num:print("电话号码不能为空")continueif not num.isdigit():print("您输入的是一个无效电话号码")continueif num.startswith('1') and len(num) == 11 and num[0:2] in cellphone_number_start:print("这是一个手机号码")continueelif num.startswith('400') and len(num) == 10:print("这是一个广告电话")continueelif num.startswith("0"):if (len(num) == 12 and num[0:4] in telephone_number_start) or(len(num) == 11 and num[0:3] in telephone_number_start):print("这是一个固定电话")continueprint("无法识别该号码")
1.2 可变序列
1.21 列表(list)
①什么是列表?
列表就是一个可变对象,可以理解为可变的元组,元素可以重复,可以存储任意类型对象,由于可变性,所以相对于元组来说,列表就多了增加、修改、删除元素的操作.
②列表的创建
代码如下:
1.创建列表
1.1 空列表
lst = [] # []
lst = list()
print(lst,type(lst))
# result: [] <class 'list'>
1.2 定义带有初始值的列表
lst = [1, 2, 3]
# result: [1, 2, 3] <class 'list'>
lst = ["a", 1, 2, 3, "b", "c"]
# result: ['a', 1, 2, 3, 'b', 'c'] <class 'list'>
lst = list(range(5))
# result: [0, 1, 2, 3, 4] <class 'list'>
lst = list("abc") #字符串转为list
# result: ['a', 'b', 'c'] <class 'list'>
lst = list((1, 2, 3)) #元组转list
# result: [1, 2, 3] <class 'list'>
③列表的CRUD
代码如下:
1.查询元素，与元组类似，可以通过索引或切片访问
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
print(my_list[2])
# result: 孙悟空
# 切片[start:end:step] start:开始位置(默认索引为0),end(结束位置),step:步长,也就是从start位置开始,到end的前一位(注意不包括索引为end这一位,左闭右开),每隔step取一个元素
print(my_list[1:3])
# result: ['唐僧', '孙悟空'] 注:从第二位开始取两位,索引为3的沙悟净娶不到(左闭右开)
2.增,添加到列表末尾,每次只能添加一个
#前面提到过list元素可变,修改前后地址不变在此再验证下
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
#修改前
print(my_list,id(my_list))
# result: ['猪八戒', '唐僧', '孙悟空', '沙悟净', '白龙马'] 1544579856000
my_list.append('蜘蛛精')
#修改后(修改前后list内存地址不变)
# result: ['猪八戒', '唐僧', '孙悟空', '沙悟净', '白龙马', '蜘蛛精'] 1544579856000
2.1 要想一次添加多个，用extend
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
my_list.extend(['蜘蛛精','蝎子精'])
# result: ['猪八戒', '唐僧', '孙悟空', '沙悟净', '白龙马', '蜘蛛精', '蝎子精']
3.删除元素
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
#开除白龙马
del my_list[4] #按照索引位置进行删除
# result: ['猪八戒', '唐僧', '孙悟空', '沙悟净']
del my_list #如果不加索引的这种写法,就会将my_list这个列表对象删除,打印my_list会提示对象未定义,因为已经被整体删除
print(my_list)
# result: NameError: name 'my_list' is not defined
4.修改元素,与查询类似直接通过索引修改
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
my_list[4] = '黑龙驴' #新物种诞生
# result: ['猪八戒', '唐僧', '孙悟空', '沙悟净', '黑龙驴']
④列表的遍历
遍历与元组相同
#遍历：
my_list = ['魔礼海', '魔礼青', '魔礼寿', '魔礼红']
1.通过while循环来遍历列表
i = 0
while i < len(my_list):print(my_list[i])i += 1
2.通过for循环来遍历列表
# 语法：
for i in my_list :print(i)
⑤常用函数
# 列表函数 与tuple一样，list也有index和count函数和支持len，不在赘述
1.insert()，区别于append()的是，insert可以指定位置插入
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
#在第一个位置插入
my_list.insert(0,'女儿国国王')
# result: ['女儿国国王', '猪八戒', '唐僧', '孙悟空', '沙悟净', '白龙马']
#在最后位置插入，注意不是拼接到最后,相当于插入到倒数第二个位置(还记得-1是最后一个位置吗?)
my_list.insert(-1,'蜘蛛精')
# result: ['女儿国国王', '猪八戒', '唐僧', '孙悟空', '沙悟净', '蜘蛛精', '白龙马']
2.pop(),不加参数则从列表尾部开始删除一个元素，并返回被删除的元素值，
#加参数，相当于将指定位置的元素删除并返回被删除的元素值
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
#默认不加参数，删除白龙马并返回白龙马
del_user = my_list.pop()
print(del_user,my_list)
# result: 白龙马 ['猪八戒', '唐僧', '孙悟空', '沙悟净']
#加参数pop
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
del_user = my_list.pop(1)
print(del_user,my_list)
# result: 唐僧 ['猪八戒', '孙悟空', '沙悟净', '白龙马']
3.remove()：通过匹配值来删除元素，前面的del 是通过索引删除元素，
# remove从左至右找到与指定的值相匹配的第一个元素，并将它删除
my_list = ['猪八戒','猪八戒','唐僧','孙悟空','沙悟净','白龙马']
my_list.remove('猪八戒')
#可以看到，尽管有两个猪八戒，但是remove只删除了从左到右的第一个猪八戒
print(my_list)
# result: ['猪八戒', '唐僧', '孙悟空', '沙悟净', '白龙马']
4.clear()清空列表中所有元素(与del my_list不同的是clear清空元素,my_list还在,只不过里面没有元素了,而del my_list直接将其在内存中删除)
my_list = ['猪八戒','唐僧','孙悟空','沙悟净','白龙马']
my_list.clear()
print(my_list)
# result: [] 注:没有任何元素的空列表
5.reverse()，列表反转(与原来顺序相反)
my_list = [1,2,3,4,5]
my_list.reverse()
print(my_list)
# result: [5, 4, 3, 2, 1]
6.sort(),将列表中元素排序(按照元素的ASCII码值升序排序）
my_list = [5,2,6,1,7]
my_list.sort()
print(my_list)
# result: [1, 2, 5, 6, 7]
# 如果对字符串进行排序，比对每个字符串的第一个字符，
# 如果第一个字符相同，则比对第二个字符，以此类推
fruits = ['apple', 'banana', 'orange', 'blueberry']
fruits.sort()
print(fruits)
# result: ['apple', 'banana', 'blueberry', 'orange']
#降序排序
my_list.sort(reverse= True)
print(my_list)
# result: [7, 6, 5, 2, 1]
7.内置函数ord()：将字符转换成对应的ASCII码值chr()：ASCII码值转成对应的字符
print(ord('A'))
# result: 65
print(chr(97))
# result: a
8.copy():顾名思义，复制列表
my_list = ['魔礼海','魔礼青','魔礼寿','魔礼红']
print(my_list)
# result: ['魔礼海', '魔礼青', '魔礼寿', '魔礼红']
my_list1 = my_list.copy()
my_list1.append('托塔李天王')
print(my_list1,my_list,sep = '---')
# result: ['魔礼海', '魔礼青', '魔礼寿', '魔礼红', '托塔李天王']---['魔礼海', '魔礼青', '魔礼寿', '魔礼红']
#可以看出对复制的my_list1进行操作时，不影响原来的my_list
#可以认为就是复制一份给my_list1,对这个备份进行任何操作都不影响原列表my_list
9.+ 和 *(千万注意,'+'和'*'操作后是生成一个新列表)
lst1 = ['魑','魅']
lst2 = ['魍','魉']
print(id(lst1),id(lst2))
lst3 = lst1 + lst2
print(id(lst3)) #看出lst3的地址与lst1和lst2都不同,'*'同理便不再验证
# result: 1544576981568 1544577003072
# 1544574292608
# +可以将两个列表拼接为一个列表
my_list = [1,2,3] + [4,5,6]
print(my_list)
# result: [1, 2, 3, 4, 5, 6]
# * 可以将列表重复指定的次数
my_list = [1,2,3] * 5
print(my_list)
# result: [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
10.in 和 not in(判断指定元素是在/不在列表中)
my_list = ['魔礼海','魔礼青','魔礼寿','魔礼红']
print('王二小' not in my_list)
# result:True
print('王二小' in my_list)
# result: Fales
print('魔礼红' in my_list)
# result: True
11.附加可变对象
# 可变对象
a = [1,2,3]
print('原列表：', a , id(a))
# result: [1, 2, 3] 1940966477056
#修改元素，不会改变对象地址，只是将这个对象中的value修改了
a[0] = 10
print('修改元素后：', a , id(a))
# result: [10, 2, 3] 1940966477056
#重新赋值相当于在内存中重新创建个对象，所以id(a)会改变
a = [4,5,6]
print('重新赋值后：', a , id(a))
# result: [4, 5, 6] 1940966776576 注:发现地址变了
#再例如
a = [1,2,3]
#将变量a指向的地址也指向变量b
b = a
b[0] = 10
#修改b中元素，a中也被修改，因为a和b指向同一个地址
#可以理解为a为在PC上面的一个文档a.txt,那么b就是a.txt的一个快捷方式,无论修改哪个,都是同步修改的
print("a",a,id(a)) #a [10, 2, 3] 1985547734272
print("b",b,id(b)) #b [10, 2, 3] 1985547734272
# 判断对象
# == != 比较的是对象的值是否相等(包含的元素是否完全相同)
# is is not 比较的是对象的id是否相等（比较两个对象是否是同一个对象）
a = [1,2,3]
b = [1,2,3]
print(a,b)
# result: [1, 2, 3] [1, 2, 3]
print('a:',id(a),'-----','b:',id(b))
# result: a: 1985552309888 ----- b: 198555230995
print(a == b)
# result: True,值相等
print(a is b)
# result: False,值虽相等但不是一个对象
#此时的列表a和b可以理解为:北京的故宫太和殿和华西村故宫太和殿,可以说一模一样(认为一模一样),但是一个在北京,一个在江苏
⑥列表推导式
列表推导式是一种快捷的创建列表的表达式，可以将多行代码省略为一行(很好用)
# 列表表达式，多行代码简化成一行，非常酸爽
#需求： 求20以内偶数
1.常规写法：range(start,end,step)
my_list = []
for i in range(20):if i % 2 == 0:my_list.append(i)
print(my_list)
# result: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
2.1.用列表表达式（是不是超级爽）
my_list = [i * 2 for i in range(10)]
2.2或者
my_list = [ i for i in range(0,20,2)]
print(my_list)
# result : [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
例子2：快速打印26英文字母 (a:97)
my_list = [ chr(i) for i in range(97,97+26)] #chr():将ASCII码-->对应字符
print(my_list)
# result: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
# 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
3.含if的列表推导式
#语法: [ value for i in x if ×××] 解释:先进入for循环,然后如果×××为真,则返回value
lst1 = list(range(21))
lst = [i for i in lst1 if i%2 == 1] #打印20以内所有奇数
print(lst)
# result: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
4.含if...else...的列表表达式
#语法: [value if...else...for i in y]
lst1 = list(range(21))
lst = [ i if i%2 == 1 else 0 for i in lst1] #20以内遇到奇数原样输出,偶数置为0
# result: [0, 1, 0, 3, 0, 5, 0, 7, 0, 9, 0, 11, 0, 13, 0, 15, 0, 17, 0, 19, 0]
⑦练习
#是否还记得这个销冠case,说明：sales中代表每个销售员姓名以一季度（1，2，3月）的业绩
# 需求：按一季度业绩降序输出各个销售员名字以及对应业绩
sales = (("Peter", (78, 70, 65)),("John", (88, 80, 85)),("Tony", (90, 99, 95)),("Henry", (80, 70, 55)),("Mike", (95, 90, 95)),
)
#常规做法
top_sales = []
for name, quarter_amount in sales:total_amount = sum(quarter_amount)top_sales.append((name, total_amount))# 此处解释下lambda 输入值: 返回值 --匿名函数,此处也就是输入x,返回x第二列元素,此处的作用是sort排序规则按照第二列的季度业绩进行降序排列top_sales.sort(key=lambda x:x[1], reverse=True)
print(top_sales)
# result: [('Tony', 284), ('Mike', 280), ('John', 253), ('Peter', 213), ('Henry', 205)]
#列表表达式做法
name_sales = [(name,sum(quarter_amount)) for name,quarter_amount in sales]
name_sales.sort(key= lambda sale:sale[1],reverse= True)
print(name_sales)
# result: [('Tony', 284), ('Mike', 280), ('John', 253), ('Peter', 213), ('Henry', 205)]
1.3 其他对象
1.31 集合
①什么是集合?
外面像字典,里面是列表,无序不重复,集合中只能存储不可变对象,一旦添加只能删除,不能修改
②集合的创建
#集合,外面像字典,里面是列表,无序不重复
1.与字典类型,都是{}但是字典中是键值对,集合中是单个元素
my_set = {1,2,3,4,5}
print(my_set,type(my_set))
# result: {1, 2, 3, 4, 5} <class 'set'>
2.列表转集合
my_set1 = set([1, 2, 3, 4, 5])
print(my_set1,type(my_set1))
# result: {1, 2, 3, 4, 5} <class 'set'>
# 验证不重复性,达到去重效果
lst = ['金','木','水','火','土','金','水']
print('转换前：',lst)
#nresult: 转换前： ['金', '木', '水', '火', '土', '金', '水']
lst1 = list(set(lst))
print('转换后：',lst1)
# result: 转换后： ['水', '土', '金', '木', '火']
#通过set给元组去重
tup = ('a','b','a','a','m')
print(tup)
# result : ('a', 'b', 'a', 'a', 'm')
num = set(tup) #元组转集合,达到去重效果
tup1= tuple(num) # 集合转元组
print(tup1)
# result: ('m', 'b', 'a')
③集合的CRUD
#集合中元素一旦添加不可修改,所以集合没有修改方法
1.添加
my_set = {1,2,3,6}
my_set.add(5)
print(my_set)
# result: 原来没有则添加：{1, 2, 3, 5, 6}
my_set.add(2)
print(my_set)
# result: 原来有则不采取任何动作,保持不变：{1, 2, 3, 5, 6}
2.删除(set元素无法修改，只能删除）
my_set = {1,2,3,6}
my_set.remove(2) #注意此处的2不是索引是值,因为集合无序,所以索引便无意义
print(my_set)
# result: {1, 3, 6}
#删除不存在的元素，会报错
my_set.remove(8)
print(my_set)
# result: KeyError: 8
#改用discard,如果没有8,没有任何反应
my_set.discard(8)
print(my_set)
# result: {1, 3, 6}
#删除值,并返回被删除的值,pop
while len(my_set) > 0:print(my_set.pop())
print(my_set)
# result: set()
#clear() 清空集合
my_set = {'I','love','Python','!'}
my_set.clear()
print(my_set)
# result : set() #空集
3.查：set由于无序，所以不能通过索引访问特定元素，只能通过遍历
或者将list(set)转换成list进行索引查询， in 也只能判断是否存在
④集合的遍历
#遍历集合,与遍历元组和列表是一样的
my_set = {'张三','李四','王二','李四','张三','头大'}
for st in my_set:print(st)
#结果再次说明了集合的不重复性以及无序特性
# result: 王二
# 头大
# 张三
# 李四
⑤常用函数
s1 = {'b','c','d'}
s2 = {'a','b','c'}
1.交集(查询两个集合中共有的元素)
print(s1.intersection(s2))
# s1 & s2 #不同写法同种功能
# result: {'b', 'c'}
2.并集(查询出两个集合中所有元素并去重)
s3 = s1.union(s2)
# s3 = s1 | s2 #不同写法同种功能
print(s3)
# result: {'a', 'b', 'd', 'c'}
3.判断是否是子集(s3中元是否覆盖s1中所有元素)
s1 = {'b','c','d'}
s3 = {'a', 'b', 'd', 'c'}
print(s1.issubset(s3))
# result: True
4.判断是否为父级
s2 = {'a','b','c'}
s3 = {'a', 'b', 'd', 'c'}
print(s3.issuperset(s2))
# True
5.差集
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}
result = s - s2
# result: {1, 2}
6.异或集 获取只在一个集合中出现在另一个集合没有(也就是两个集合特有的元素组成的并集)的元素
s = {1,2,3,4,5} #特有元素 1,2
s2 = {3,4,5,6,7} #特有元素 6,7
result = s ^ s2 # 结果即为 1,2 和 6,7 组成的并集
# result: {1, 2, 6, 7}
7.<= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}
result = a <= b
# result: True
result = {1,2,3} <= {1,2,3}
# result: True
result = {1,2,3,4,5} <= {1,2,3}
# result: False
8.< 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集(简单讲就是,如果集合a是集合b的真子集,则b集合元素个数>a集合元素个数且a集合中元素都存在于b集合)
result = {1,2,3} < {1,2,3} #这种情况是子集,而不是真子集
# result: False
result = {1,2,3} < {1,2,3,4,5}
# result: True
同理:>= 检查一个集合是否是另一个的超集(父集) (这里不再举例说明)> 检查一个集合是否是另一个的真超集(父集)
9.== 判断两个集合中元素是否完全相同
a = {1,'a',False,None,6.6}
b = {1,'a',False,None}
c = {1,'a',False,None,6.6}
print(a==b,a==c)
# result: False True 注:元素相同不一定是同一个对象
10.is,is not 判断两个集合是否是同一个对象
a = {1,'a',False,None,6.6}
c = {1,'a',False,None,6.6}
print('a和c元素是否相同',a==c)
# result: a和c元素是否相同 True
print('a和c是否为同一对象',a is c)
# result: a和c是否为同一对象 False
print(id(a),id(c)) #显然两者id不同,不是同一个对象
# result: 2508129052928 2508129051360
11.in 判断元素是否在集合中(而不是一个集合的元素是否在另一个集合中)
a = {1,'er','three',0.1}
b = {1,'er'}
print('er' in a )
# result: True
print(b in a)
# result: False
12.集合表达式(与列表相似)
my_set = { i if i % 2 == 0 else None for i in range(20)}
print(my_set) #结果相当于将所有偶数,以及10个None去重后的并集
# result: {0, 2, 4, 6, None, 8, 10, 12, 14, 16, 18}
13.copy()
my_set={'魑','魅','魍','魉'}
my_set1 = my_set.copy()
print(my_set,':',id(my_set))
print(my_set1,':',id(my_set1 )) #复制后相当于在内存中新建一个元素与my_set相同的新集合(因为两者地址(id值)不同),只要地址不同,操作任意集合中元素都不会对另一个集合有影响
# result: {'魅', '魉', '魑', '魍'} : 2508149967776
# {'魅', '魉', '魑', '魍'} : 25081499673281.32 字典
①什么是字典?
字典属于一种新的数据结构,也称为映射(mapping),key:value形式,字典的值可以是任意对象,字典的键可以是任意的不可变对象（int、str、bool、tuple …），但是一般我们都会使用str,字典的键是不能重复的，如果出现重复的,后添加的键值将会覆盖之前的值
②字典的创建
#创建字典
1.定义一个空字典(用花括号{},还记得元组是小括号'()',列表是中括号'[]')
my_dict = {}
print(my_dict,type(my_dict))
# result: {} <class 'dict'>
2.定义非空字典1:
sales = {'郭靖': '襄阳','张无忌': '光明顶','灭绝师太': '峨眉山','唐僧': '东土大唐','黄老邪': '桃花岛'
}
print(sales)
# result: {'郭靖': '襄阳', '张无忌': '光明顶', '灭绝师太': '峨眉山', '唐僧': '东土大唐', '黄老邪': '桃花岛'}
3.使用 dict()函数来创建字典
# 每一个参数都是一个键值对，参数名(name,age,gender)就是键，参数名('Whilesoul'，27，'男')就是值（这种方式创建的字典，key都是字符串）
my_dict = dict(name='Whilesoul',age=27,gender='男')
print(my_dict,type(my_dict))
# result: {'name': 'Whilesoul', 'age': 27, 'gender': '男'} <class 'dict'>
4.也可以将一个含有元素类型为序列且为双值的序列转换为字典
# [(1,2),(3,5),'ok',[5,'21']]
d = dict([('name','曾国藩'),('age',50),('address','湖南'),'AJ',[1,2]])
print(d , type(d))
# result: {'name': '曾国藩', 'age': 50, 'address': '湖南', 'A': 'J', 1: 2} <class 'dict'>
5.zip(拉链,很生动,将两个序列拉成一起,一组为key,另一组为value)
lst1 = ['name','age','gender']
lst2 = ['林志颖',18,'男']
my_dict = dict(zip(lst1,lst2)) # zip(a,b):a为key,b为value
print(my_dict)
# result: {'name': '林志颖', 'age': 18, 'gender': '男'}
③字典的CRUD
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
1.查(通过key查询value)
print(my_dict['Amy'],my_dict['Bob'])
# result: 14 15
#如果查询的key不存在，会报错
my_dict['lucy']
# result: KeyError: 'lucy'
2.增(也是通过key和value进行添加，判断key如果dict中没有则将key:value加入，如果存在key,则新value覆盖原value)
#原来不存在则加入
my_dict['David'] = '20'
print(my_dict) #没有则新增
# result: {'Tom': 12, 'Jerry': 8, 'Amy': 14, 'Bob': 15, 'Lucy': 10, 'David': '20'}
#原来已有对应的key则更新对应的value值
my_dict['Lucy'] = '520'
print(my_dict) #将lucy的value 更新为520
# result: {'Tom': 12, 'Jerry': 8, 'Amy': 14, 'Bob': 15, 'Lucy': '520', 'David': '20'}
3.改(通过键来改值)
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10,'David':20 }
my_dict['David'] = '88'
print(my_dict)
# result: {'Tom': 12, 'Jerry': 8, 'Amy': 14, 'Bob': 15, 'Lucy': 10, 'David': '88'}
4.删(通过指定key将key:value同时删除)
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10,'David':20 }
del my_dict['David']
print(my_dict)
# result: {'Tom': 12, 'Jerry': 8, 'Amy': 14, 'Bob': 15, 'Lucy': 10}
④字典的遍历
1.遍历键和值
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
#遍历,将内容以元组形式输出
for key_value in my_dict.items():print(key_value,end= ',')
# result: ('Tom', 12),('Jerry', 8),('Amy', 14),('Bob', 15),('Lucy', 10)
2.遍历键和值
#遍历字典(重要)，key和value同时取出
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
for key,value in my_dict.items():print(key,':',value, end = ',')
# result: Tom : 12 ,Jerry : 8 ,Amy : 14 ,Bob : 15 ,Lucy : 10
3.不加item（相当于遍历key）
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
for key in my_dict:print(key, end = ', ')
# result: Tom, Jerry, Amy, Bob, Lucy
⑤常用函数
1.get(key,defaultvalue)
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
#前面已经知道如果目标key在字典中没有，执行my_dict['erha']会报错
print(my_dict['erha'])
# result: KeyError: 'erha'
print(my_dict.get('erha'))
# result: None
#也可以设定一个在查不到时的默认值
print(my_dict.get('erha','NoFound'))
# result: NoFound
2.keys() 获取keys
#效果与for key in my_dict:# print(key) 相同
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
print(my_dict.keys()) #打印所有的key
# result: dict_keys(['Tom', 'Jerry', 'Amy', 'Bob', 'Lucy'])
3.values() 获取values
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
print(my_dict.values())
# result: dict_values([12, 8, 14, 15, 10])
for value in my_dict.values():print(value,end = ', ')
#result: 12, 8, 14, 15, 10
#求得所有人员的年龄和
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
print(sum(my_dict.values()))
# result: 59
4.len() 获取字典中键值对的个数
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
len(my_dict)
# result: 5
5.in 检查字典中是否包含指定的键
# not in 检查字典中是否不包含指定的键
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
'Jerry' in my_dict #True
'erha' in my_dict #False
'ant' not in my_dict #True
6.setdefault(key[, default]) 可以用来向字典中添加key-value
# 如果key已经存在于字典中，则返回value值，不会对字典做任何操作
# 如果key不存在，则向字典中添加这个key:value,并返回value值
my_dict = {'Tom':12,'Jerry': 8,'Amy':14,'Bob':15,'Lucy':10 }
#没有此key,将key:value加入，并返回value值
result1 = my_dict.setdefault('name','猪八戒')
print(result1,my_dict)
# result: 猪八戒 {'Tom': 12, 'Jerry': 8, 'Amy': 14, 'Bob': 15, 'Lucy': 10, 'name': '猪八戒'}
#有此key,不进行任何操作,返回原value值
result2 = my_dict.setdefault('name','二郎神')
print(result2,my_dict)
# result :猪八戒 {'Tom': 12, 'Jerry': 8, 'Amy': 14, 'Bob': 15, 'Lucy': 10, 'name': '猪八戒'}
7.update([other])
# 将其他的字典中的key-value添加到当前字典中
# 如果有重复的key，则后边的value会替换到当前的value(有则改之无则加入)
dic = {'a':1,'b':2,'c':3}
dic1 = {'e':5,'d':4,'t':6, 'a':7}
dic.update(dic1)
print(dic)
# result: {'a': 7, 'b': 2, 'c': 3, 'e': 5, 'd': 4, 't': 6}
8.popitem()
# 随机删除字典中的一个键值对，一般都会删除最后一个键值对
# 删除之后，它会将删除的key-value作为返回值返回
# 返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
# 当使用popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'
my_dict = dict(name = 'erha',age = 8,hobby = 'destroy')
dc =my_dict.popitem()
print(dc,my_dict)
# result: ('hobby', 'destroy') {'name': 'erha', 'age': 8}
9.pop(key[, default])
# 根据key删除字典中的key-value
# 会将被删除的value返回！
# 如果删除不存在的key，会抛出异常
# 如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
my_dict = dict(name = 'erha',age = 8,hobby = 'destroy')
#已有key
result =my_dict.pop('name')
print(result,my_dict)
# result: erha {'age': 8, 'hobby': 'destroy'}
#未有key
result = my_dict.pop('sha','No found')
print(result,my_dict)
# result: No found {'age': 8, 'hobby': 'destroy'}
10 clear()用来清空字典
my_dict = dict(name = 'erha',age = 8,hobby = 'destroy')
print(my_dict)
# result: {'name': 'erha', 'age': 8, 'hobby': 'destroy'}
my_dict.clear()
print(my_dict)
# result: {}
11.copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
my_dict = dict(name = 'erha',age = 8,hobby = 'destroy')
my_dict1 = my_dict.copy()
#修改my_dict看对my_dict1是否有影响，结果：无影响
my_dict['name'] = 'lv'
print(my_dict,my_dict1)
# result: {'name': 'lv', 'age': 8, 'hobby': 'destroy'} {'name': 'erha', 'age': 8, 'hobby': 'destroy'}
#修改my_dict1看对my_dict是否有影响，结果：无影响
my_dict = dict(name = 'erha',age = 8,hobby = 'destroy')
my_dict1 = my_dict.copy()
my_dict1['name'] = 'lv'
print(my_dict,my_dict1)
# result: {'name': 'erha', 'age': 8, 'hobby': 'destroy'} {'name': 'lv', 'age': 8, 'hobby': 'destroy'}
#内部值也是可变对象（理解为将可变对象的地址复制了一份）
d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy()
print(id(d),id(d2)) #赋值后二者地址就不一样
# result: 1544580798592 1544580800192
d2['a']['name'] = '猪八戒'
dd1 = d['a']
dd2 = d2['a']
print(id(dd1),id(dd2))
# result:2548494068928 2548494068928 可变key地址相同()
#也就是说如果key:value中的value也是可变对象，那么复制后，可变对象的地址和复制前相同，修改一个，另一个也会改变
print('d = ',d , id(d))
# result: d = {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3} 1544580798592
print('d2 = ',d2 , id(d2))
# result: d2 = {'a': {'name': '猪八戒', 'age': 18}, 'b': 2, 'c': 3} 1544580800192
脑图:(目前只写了基础数据结构这块,其他的后续会慢慢更新)
结束语:
各位看客老爷们,感谢您的阅读,到此文章就算完结了,由于本人是小白而且第一次写这种博客,难免有纰漏,如有错误望看客老爷们指出,我会及时修正,同时也希望这篇文章会给像我一样的初学者带来一丢丢的帮助. – 原创不易,转载请说明出处,谢谢!
更多推荐
数据分析Python基础
发布评论