自学Python Day_02-CFANZ编程社区

文章目录

遍历列表

for循环实现
for循环和enumerate()函数

列表排序

列表对象方法sort()
sorted()函数
列表推导式

快速生成一个列表完成指定要求的列表
根据列表生成指定要求的列表
从列表中选择符合条件的元素组成新的列表

总结

元组

元组的基本操作

创建元组
更新元组、拼接操作
删除元组

总结

字典

字典格式
字典的定义与输出
字典元素的修改、增加、删除
建立空字典
已有数据快速建立空字典
通过给定的“键值对”创建字典
使用dict对象的fromkeys()方法创建值为空的字典
遍历字典
字典内置函数和方法

集合

创建集合
添加、删除集合
集合的交集、并集、差集
总结

总结

列表在前一篇文章中也有讲到一些，可供参考。【自学Python Day_01】

遍历列表

【参考GitHub源码】

for循环实现

遍历所有元素，完成处理、查询等操作

print("2018年俄罗斯世界杯四强：")
team=["法国","比利时","英格兰","克罗地亚"]
for i in team:
   print(i)

for循环，从team中取一个元素，输出

运行结果：

2018年俄罗斯世界杯四强：
法国
比利时
英格兰
克罗地亚

for循环和enumerate()函数

print("2018年俄罗斯世界杯四强：")
team=["法国","比利时","英格兰","克罗地亚"]
for index,item in enumerate(team):
   print(index+1,item)

enumerate()函数是Python内置函数，用于计数，可以同时获得索引和值。返回的是一个enumerate对象

运行结果：

2018年俄罗斯世界杯四强：
1 法国
2 比利时
3 英格兰
4 克罗地亚

列表排序

列表对象方法sort()

升序、降序操作，原列表发生改变
语法：listname.sort(key=None,reverse=False)

listname 列表名称
key 指定一个从每个列表元素是猴子那个提取一个用于比较的键。如key=str.lower表示排序时不区分大小写
reverse 可选参数，指定True为降序，False为升序，默认为升序

grade=[98,97,86,88,100,65,74,80]

# 默认升序
print("原列表",grade)

# 升序排序
grade.sort()
print("升序",grade)

# 降序排序
grade.sort(reverse=True)
print("降序",grade)

分别输出列表的原序列、升序序列和降序序列

运行结果：

原列表 [98, 97, 86, 88, 100, 65, 74, 80]
升序 [65, 74, 80, 86, 88, 97, 98, 100]
降序 [100, 98, 97, 88, 86, 80, 74, 65]

以上是对数值的排序，那对字符串的排序呢？

char=["Bad","jay","Leo","Stare","tom"]

# 默认区分大小写
char.sort()
print(char)

# 不区分大小写
char.sort(key=str.lower)
print(char)

运行结果：

['Bad', 'Leo', 'Stare', 'jay', 'tom']
['Bad', 'jay', 'Leo', 'Stare', 'tom']

sorted()函数

升序、降序操作，原列表不变
语法：sorted(iterable,key=None,reverse=False)

iterable 列表名称
key 指定一个从每个列表元素中提取一个用于比较的键
reverse 可选参数，指定True为降序,False为降序，默认升序

grade=[98,97,86,88,100,65,74,80]
print("原序列",grade)

# 因为sorted不会使原列表改变，所以需要重新定义列表，输出
grade_as=sorted(grade)
print("升序",grade_as)

# 这里同上，降序输出
grade_des=sorted(grade,reverse=True)
print("降序",grade_des)

运行结果：

原序列 [98, 97, 86, 88, 100, 65, 74, 80]
升序 [65, 74, 80, 86, 88, 97, 98, 100]
降序 [100, 98, 97, 88, 86, 80, 74, 65]

列表推导式

快速生成一个列表完成指定要求的列表

语法：list=[Expression for var in range]

Expression 表达式，用于计算新的列表元素
var 循环变量
range 采用range()函数生成的range对象

import random

# 生成一个有10个范围在10-100之间的随机数的列表
randomnumber=[random.randint(10,100) for i in range(10)]
print("生成的随机数为：",randomnumber)

运行结果：

生成的随机数为： [99, 90, 96, 12, 23, 72, 32, 72, 59, 11]

根据列表生成指定要求的列表

语法：list=[Expression for var in list]

prince=[1200,5330,2988,6200]

# 将prince中的价格打五折生成新的列表
sale=[int(x*0.5) for x in prince]
print("打五折的价格：",sale)

运行结果：

打五折的价格: [600, 2665, 1494, 3100]

从列表中选择符合条件的元素组成新的列表

语法：list=[Expression for var in list if condition]

Expression 表达式，用于计算新的列表元素
var 循环变量，其值是后面列表每个元素的值
list 用于生成新列表的原列表
condition 条件表达式，用于指定筛选条件

price=[1200,5330,2998,6200]

# 快速生成价格高于5000的列表
sale=[i for i in price if i>5000]
print("价格高于5000的：",sale)

如果列表中的元素大于5000，则输出

运行结果：

价格高于5000的： [5330, 6200]

总结

函数	功能
list.append()	在列表末尾添加新的元素
list.count()	统计某个元素在列表中出现的次数
list.extend()	在列表末尾一次性追加另一个列表中的多个值（用新列表拓展原来的列表）
list.index()	从列表中找出某个值的第一个匹配项的索引位置
list.insert()	将新元素插入列表
list.pop()	删除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove()	删除列表中某个值的第一个匹配项
list.reverse()	反向列表中的元素
list.sort()	对原列表进行排序

元组

创建元组(,)必须要使用逗号
元组与列表的最大区别是元组不可修改，只读列表
列表中的元素赋值、删除元素、分片赋值、append()、extend()、insert()、pop()、remove()、sort()等函数在元组中都不可使用
乘法、索引取值、tuple()、切片取值、成员检查、最大最小长度、count()、index()都可用，并且相同
可以将整数、实数、字符串、列表、元组等任何类型的内容存放在元组

元组的基本操作

创建元组

>>> tuple1=("abc",123,199.99)  #创建元组
>>> tuple1
('abc', 123, 199.99)
>>> tuple=(1,2,3,4)  #使用函数创建元组
>>> tuple
(1, 2, 3, 4)
>>> tuple2="Python","PHP",189
>>> tuple2
('Python', 'PHP', 189)

>>> tuple3=("许嵩",)  #创建只有一个元素的元组，要以逗号结束
>>> tuple3
('许嵩',)
>>> tuple4=1,
>>> tuple4
(1,)

>>> tuple5=("Bad")  #如果不加逗号，就是字符串类型的
>>> tuple5
'Bad'
>>> type (tuple5)
<class 'str'>
>>> type (tuple2)
<class 'tuple'>

创建只有一个元素的元组时，必须要在最后加逗号，不然就不是元组类型的
str字符串类型，tuple元组

更新元组、拼接操作

>>> tuple1=("我和我的祖国","哪吒","中国机长")
>>> tuple1
('我和我的祖国', '哪吒', '中国机长')

# 指定索引，在元组中插入元素
>>> tuple1=tuple1[:1]+("哪吒",)+tuple1[1:]
>>> tuple1
('我和我的祖国', '哪吒', '攀登者', '中国机长')

删除元组

>>> tuple1
('我和我的祖国', '哪吒', '攀登者', '中国机长')

# 删除元组
>>> del tuple1
>>> tuple1
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    tuple1
NameError: name 'tuple1' is not defined

算数运算

>>> 8*(8)  #算数运算
64
>>> 8*(9,)  #重复
(9, 9, 9, 9, 9, 9, 9, 9)

总结

序列是Python中最基本的数据结构
序列中的每个元素都分配一个数字：位置或索引，从0开始
Python有6个序列的内置类型，常见的是列表、元组
序列的操作有：索引、切片、加（组合）、乘、检查成员、长度、最小、最大元素
列表是可变序列，元组是不可变序列：元组中不可以添加、修改和删除元素
列表可以切片访问、修改元素，元组也可以切片访问，但不可修改
元组比列表的访问和处理速度快，只进行元素访问，如果不进行修改，建议使用元组
列表不能作为字典的键，而元组可以

字典

【参考GitHub源码】

自学Python Day_02_升序

“{}”标识，元素由键key和值value组成
无序的可变序列，列表是有序可变序列
值是通过键来存取的，不是通过偏移存取
键必须唯一，并且不可变

键可以使用数字、字符串、元组，但不能用列表
如果键出现两次，后一个值会被存储

字典可变，并且任意嵌套
字典有时也称为关联数组或散列表（Hash）

前段时间还听到过哈希（hash），还专门去百度了一下，hash算法可以检查文件的完整性

字典格式

语法：dict={key1:value1,key2:value2,key3:value3}

键（key）必须是唯一的，但值（value）可以是不唯一的
值可以是任何数据类型，键只能是字符串、数字、元组

例：

dict1={'Alice':'1234':'Ben':'6789':'John':'5678'}
dict2={'abc':123,98.6:78}

字典的定义与输出

dict={'Name':'Ben','Age':37,'Gender':'Male'}  #定义字典
print(dict['Name'])  #输出Name键对应的值

字典元素的修改、增加、删除

# 定义一个字典
>>> dict={'Name':'Ben','Age':37,'Gender':'Male'}
>>> dict
{'Name': 'Ben', 'Age': 37, 'Gender': 'Male'}

# 修改字典中的Age键对应的值
>>> dict['Age']=40
>>> dict
{'Name': 'Ben', 'Age': 40, 'Gender': 'Male'}

# 增加键为School，值为WTC的值
>>> dict['School']="WTC"
>>> dict
{'Name': 'Ben', 'Age': 40, 'Gender': 'Male', 'School': 'WTC'}

# 删除键为Gender的元素
>>> del dict['Gender']
>>> dict
{'Name': 'Ben', 'Age': 40, 'School': 'WTC'}

# 清空字典所有元素
>>> dict.clear()
>>> dict
{}

# 删除字典
>>> del dict
>>> dict
<class 'dict'>

键只能出现一次，出现多次，最后的值才会被存储
键不可变，列表不能作为键

建立空字典

dictionary={}
dict={}
dictionary=dict()

TypeError:'dict ' object is not callable这个报错是因为dict()是Python的内建函数，而将dict自定义为一个Python字典后，想要再调用dict()函数就会报错
解决方法：而将dict自定义为一个del (dict)

已有数据快速建立空字典

通过映射函数创建字典
语法：dictionary=dict(zip(list1,list2))

dictionary 字典的名称
zip() 函数
list1 用于指定生成字典的建
list2 用于指定生成字典的值
**返回值：**list1与list2的长度不同，则与最短列表长度相同

# 定义两个列表
name=['张三','李四','王五']
sign=['001','002','003']

# 通过列表，直接创建字典
dictionary=dict(zip(name,sign))

print(dictionary)

运行结果：

{'张三': '001', '李四': '002', '王五': '003'}

通过给定的“键值对”创建字典

语法：dictionary=dict(key1=value,key2=value2,……,keyn=valuen)

dictionary=dict(张三='001',李四='002',王五='003')
print(dictionary)

运行结果：

{'张三': '001', '李四': '002', '王五': '003'}

使用dict对象的fromkeys()方法创建值为空的字典

语法：dictionary=dict.formkeys(list1)

name_list=['张三','李四','王五']
dictionary=dict.fromkeys(name_list)

print(dictionary)

运行结果：

{'张三': None, '李四': None, '王五': None}

name_tuple=("张三","李四","王五")
sign=['001','002','003']

dict1={name_tuple:sign}

print(dict1)

运行结果：

{('张三', '李四', '王五'): ['001', '002', '003']}

遍历字典

items()方法可以获取字典的“键值对”列表
配合for循环遍历该元组列表
key()、value()与items()方法类似，配合for循环

dictionary={'qq':'123456',"歌曲":"山水之间"}

for item in dictionary.items():
    print(item)

for key,value in dictionary.items():
    print(key,value)

运行结果：

('qq', '123456')
('歌曲', '山水之间')
qq 123456
歌曲 山水之间

在字典这一节，确实会变得有点难理解了，所以要多看几遍，多加练习！
这个地方当时在定义字典的时候，打错了符号，结果去问????肉肉，过了一会儿，突然问我一句“你给我解释一下什么是字典”，woc！当时那叫一个心慌慌，有种睡了一节课，快下课被老师点名的感觉！！！

字典推导式

import random

randomdict={i:random.randint(10,100) for i in range(1,5)}
print("生成的字典为：",randomdict)

运行结果：

生成的字典为： {1: 75, 2: 10, 3: 10, 4: 90}

字典内置函数和方法

函数式	功能
cmp(dict1,dict2)	比较两个字典元素
len(dict)	计算字典元素的个数，即键的总和
str(dict)	输出字典可打印的字符串表示
type(variable)	返回输入的变量类型，如果变量是字典，就返回字典类型
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.fromkers(seq[,val])	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key,default=None)	返回指定键的值，如果不在字典中，返回default值
dict.has_key(key)	如果键在字典dict里返回true，否则返回false
dict.items()	以列表返回可遍历的（键、值）元组数组
dict.keys()	以列表返回一个字典所有的键
dict.setdefault(key,default=None)	和get类似，如果键不存在与字典中，将会添加键并将值设为default
dict.update(dict2)	把字典dict2的键值对更新到dict里
dict.values()	以列表返回字典中的所有值
pop(key[,default])	删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出，否则返回default值
popitem()	随机返回并删除字典中的一对键和值

集合

【参考GitHub源码】

用于保存不重复元素
有可变集合（set）、不可变集合（frozenset）
set集合是无序可变列表
常用操作：创建集合、天界、删除、交集、并集、差集

创建集合

直接使用{}创建，和元组、列表、字典一样，直接将集合赋值给变量

setname={element1,element2,……,elementn}

使用set()函数创建，将列表、元组等其他可迭代对象转换成集合

setname=set(iteration)

创建的集合有重复值，自动保留一个
集合是无序的，每次输出时会产生不同排列顺序的集合
创建空集合使用set()，因为{}是用来创建空字典的
推荐使用set{}创建集合

set1={"Monday","Tuesday","Wednesday","Thursday","Friday"}
set2=set("面朝大海，春暖花开")
set3=set([1,123,4.56])
set4=set(('以梦为马','不负韶华'))

print(set1)
print(set2)
print(set3)
print(set4)

运行结果：

{'Tuesday', 'Monday', 'Thursday', 'Wednesday', 'Friday'}
{'春', '暖', '朝', '花', '开', '，', '大', '海', '面'}
{1, 123, 4.56}
{'以梦为马', '不负韶华'}

添加、删除集合

add

语法：setname.add(element)

只能使用字符串、数字、布尔型，不能使用列表、元组等可迭代对象

del

语法：

del 删除整个集合
pop()、remove() 删除一个元素
clear() 清空整个集合，成为空集合

# 定义一个集合
>>> set1={"Monday","Tuesday","Wednesday"}
>>> set1
{'Wednesday', 'Tuesday', 'Monday'}

# 向集合中添加元素，add一次只能添加一个元素
>>> set1.add("Thursday")
>>> set1
{'Wednesday', 'Tuesday', 'Thursday', 'Monday'}

# 删除集合中的元素
>>> set1.remove("Monday")
>>> set1
{'Wednesday', 'Tuesday', 'Thursday'}

# pop删除元素会有返回值
>>> set1.pop()
'Wednesday'
>>> set1
{'Tuesday', 'Thursday'}

集合的交集、并集、差集

& 交集
| 并集
- 差集

pf=set(["许嵩","孙子涵","李荣浩"])
cf=set(["许嵩","薛之谦","周杰伦"])

print("交集运算：",pf&cf)
print("并集运算：",pf|cf)
print("差集运算：",pf-cf)

运行结果：

交集运算： {'许嵩'}
并集运算： {'李荣浩', '许嵩', '周杰伦', '孙子涵', '薛之谦'}
差集运算： {'孙子涵', '李荣浩'}

总结

列表：允许有重复项，类型可以不同
元组：结构上和列表相同，但是元组只读
字典：存储键值对数据，可以通过键查找值
集合：数学中的集合，无特殊意义，无特殊表示方法，通过set()函数转换成集合。集合可以去重。

list=[1,1,2,3,4,5,6,1,2,]
list_set=set(list)

print(list_set)

tuple=(10,10,9)
tuple_set=set(tuple)

print(tuple_set)

运算结果：

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

总结

最后总结一下列表、元组、字典、集合的异同点。

数据结构	是否可变	是否重复	是否有序	定义符号
列表	可变	可重复	有序	[]
元组	不可变	可重复	有序	()
字典	可变	可重复	无序	{key:value}
集合	可变	不可重复	无序	{}

以上内容均属原创，如有不详或错误，敬请指出。

本文作者：坏坏