python基础day4-优快云博客

本文链接：https://blog.youkuaiyun.com/joekl/article/details/146249164

一.容器

1.Python列表(list)

Python 支持多种复合数据类型，可将不同值组合在一起。最常用的列表，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同

列表是一种可以存储任意个各种类型的序列容器
列表内的数据有先后顺序关系
列表是可变的容器
>>> L = [] # 创建一个空的列表
>>> L = ['北京', '上海', '广州', '西安'] # 创建一个含有4个字符串的列表
>>> L = [1, 'Two', 3.14, True, False, None]
>>> L = [1, 2, [3.1, 3.2], 4] # 含有四个元素的列表，第三个元素是列表
>>> L2 = [
   ['姓名','语文成绩','数学成绩'],
   ['小王', 90, 100],
   ['牛犇', 59, 26]
]
①列表的运算
+ 用于拼接列表

L1 = [1,2,3]
L2 = ["A","B","C"]
print(L1+L2) 



[1, 2, 3, 'A', 'B', 'C']

+= 追加

L1 = [1,2,3]
L1 +='adsa'
print(L1)

[1, 2, 3, 'a', 'd', 's', 'a']

* 用于生产重复的列表

L1 = [1,2,3]
L2 = 3*L1
print(L2)




[1, 2, 3, 1, 2, 3, 1, 2, 3]

== != 用于比较

```
print([1,2,3]==[1,2,3])
print([1,2]!=[2])



True
True
```
in /not in 用于判断一个数据元素是否在列表中

l1 = ['zhansan','lisi']
print('zhansan'in l1)
print('lisi' not in l1)



True
False

②.访问列表中的值

2.1正向索引
```
l1 = [1,2,3]
print(l1[0])
print(l1[1])



1
2
```
与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。
2.2 反向索引
```
l1 = [1,2,3]
print(l1[-1])
print(l1[-2])



3
2
```
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推
2.3 切片
列表[(开始索引b):(终止索引e)(: (步长s))]

l1 = [1,2,3,4,5,6,7,8,9]
print(l1[0:4])
print(l1[::-1])            # 反向切片
print(l1[::2])             # 取奇数




[1, 2, 3, 4]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
[1, 3, 5, 7, 9]

③列表的数据操作(增、删、改、查)

3.1 添加数据（增）


方法	说明
L.append(x)	向列表的末尾追加单个数据
L.insert(index, obj)	将某个数据obj 插入到 index这个索引位置的数据之前
L.extend(可迭代对象)	等同于: L += 可迭代对象，如列表、元组、字符串、集合等

l1 = [1,3,5]
l1.append(6)
print(l1)

l1.insert(1,2)
print(l1)

l1.extend(range(7,10))
print(l1)




[1, 3, 5, 6]
[1, 2, 3, 5, 6]
[1, 2, 3, 5, 6, 7, 8, 9]

3.2 修改数据 (改)

用索引赋值可以改变列表内的数据

l1 = [1,3,5]
l1[2]=7
print(l1)


[1, 3, 7]

3.3 删除数据 (删)

方法	说明
L.remove(x)	从列表L中删除第一次出现在列表中的数据元素，如果x不存在则报错
L.pop()	根据索引删除元素，并返回该元素。若不提供索引，默认删除最后一个元素
L.clear()	清空列表

l1 = [1,2,2,3]
l1 .remove(2)
print(l1)

l1.pop()
print(l1)
l1.pop(1)
print(l1)

l1 = ['zhangsan','lisi','wangwu']
l1.clear()
print(l1)


[1, 2, 3]
[1, 2]
[1]
[]

del 语句删除指定位置的数据元素

l1=[12,2]
del l1[0]
print(l1)
del l1
print(l1)



[2]

NameError: name 'l1' is not defined

④.嵌套列表

使用嵌套列表即在列表里创建其它列表
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)#[['a', 'b', 'c'], [1, 2, 3]]
print(x[0])#['a', 'b', 'c']
print(x[0][1])#b

⑤.Python列表常用API

序号	函数
1	len(list)列表元素个数
2	max(list)返回列表元素最大值
3	min(list)返回列表元素最小值
4	list(seq)将元组转换为列表

列表的常用方法

运算	结果
`s.index(x[, i[, j]])`	x 在 s 中首次出现项的索引号（索引号在 i 或其后且在 j 之前）
`s.count(x)`	x 在 s 中出现的总次数
`s.append(x)`	将 x 添加到序列的末尾 (等同于 `s[len(s):len(s)] = [x]`)
`s.clear()`	从 s 中移除所有项 (等同于 `del s[:]`)
`s.copy()`	创建 s 的浅拷贝 (等同于 `s[:]`)
`s.extend(t)` 或 `s += t`	用 t 的内容扩展 s (基本上等同于 `s[len(s):len(s)] = t`)
`s.insert(i, x)`	在由 i 给出的索引位置将 x 插入 s (等同于 `s[i:i] = [x]`)
`s.pop([i])`	提取在 i 位置上的项，并将其从 s 中移除
`s.remove(x)`	删除 s 中第一个 `s[i]` 等于 x 的项目。
`s.reverse()`	就地将列表中的元素逆序。
`s.sort( key=None, reverse=False)`	对列表内的数据进行排序, reverse=False 升序排序，否则是降序排序

2.Python元组(tuple)

元组是不可改变的列表
同列表list 一样，元组可以存放任意类型的数据
但是，一旦创建将不可修改，包括添加、删除或更改其中的元素
元组使用小括号 ( )，列表使用方括号 [ ]

1.元组的创建

用小括号() 括起来，单个元素括起来后加逗号来区分单个元素还是元组

创建元组的函数 tuple

tu = (1,2,'as')
print(tu)
tu1 = tuple(range(1,4,2))
print(tu1)


(1, 2, 'as')
(1, 3)

2.元组的数据操作（删，查，运算）

2.1 删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('openAI', 'hqyj', 100, 200) 
print (tup)
del tup
print (tup)#name 'tup' is not defined

2.2 查看元组

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

tup1 = ('python', 'hqyj', 100, 200)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print (tup1[0])#python
print (tup2[1:5])#(2, 3, 4, 5)
print (tup2[:4])#(1, 2, 3, 4)
print (tup2[2:])#(3, 4, 5, 6, 7)



python
(2, 3, 4, 5)
(1, 2, 3, 4)
(3, 4, 5, 6, 7)

2.3 元组的运算

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

(12, 34.56, 'abc', 'xyz')

3.元组不可变

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

tup = (1, 2, 3, 4, 5, 6, 7)
tup[1] = 100
print(tup)#报错'tuple' object does not support item assignment

4.元组常用API

序号	方法	描述
1	len(tuple)	返回元组中元素个数。
2	max(tuple)	返回元组中元素最大值。
3	min(tuple)	返回元组中元素最小值。
4	tuple(list)	将列表转换为元组。

运算	结果
s.index(x[, i[, j]])	元素x 在 s 中首次出现项的索引号，`i`（可选）：搜索的起始索引。如果省略，将从元组的开头开始搜索，`j`（可选）：搜索的结束索引。如果省略，将搜索到元组的末尾
s.count(x)	x 在 s 中出现的总次数

3.Python字典(dict )

字典是一种可变容器模型，且可存储任意类型对象。
字典的数据都是以键(key)-值(value)对的形式进行映射存储.
字典的每个键值对( key:value )用冒号分割，每个对之间用逗号分割，整个字典包括在花括号 {} 中
d = {key1 : value1, key2 : value2, key3 : value3 }
字典的数据在Python 3.7及更高版本中，字典是有序的；3.6之前的版本中，字典是无序的
字典的键不能重复，且只能用不可变类型作为字典的键
字典中的数据只能用"键"key 进行索引，不能用整数进行索引

1.字典的创建

创建字典的字面值:

字典的表示方式以 {} 括起来，以英文的冒号 (:) 分隔键值对，各键值对之间用逗号(,)分隔

d = {}    # 创建空字典
d = {'name': "weimingze", "age": 35}
d = {'a': [1, 2, 3]}
d = {'b': {"bb": 222}}
d = {1:'壹', 2:'贰', 5:'伍'}
d = {(1, 2, 3):'壹贰伍'}

以下写法会存在问题

键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

d = {'a': 1, 'b': 2, 'a': 3}  # 字典的键不能重复 d = {'a': 3, 'b': 2}  
d = {[1, 2, 3]: 'a'}          # 不能用可变类型作为字典的键  # 报错

字典[键key] = 表达式

2.字典的数据操作（增、删、改、查）

2.1 增加和修改字典
添加和修改字典的元素
- 语法
键不存在, 会创建键并绑定键对应的值

键存在, 会改变键对应的值

dic = {'a':12,'b':13,'c':14,'a':15}
print(dic)
dic['a']=15
print(dic)
dic['d']=10
print(dic)



{'a': 15, 'b': 13, 'c': 14}
{'a': 15, 'b': 13, 'c': 14}
{'a': 15, 'b': 13, 'c': 14, 'd': 10}

2.2 访问字典里的值

用键索引可以查看字典中的数据

如果用字典里没有的键访问数据，会输出错误

dic = {'a':12,'b':13,'c':14,'a':15}
print(dic['a'])
print(dic['d'])



KeyError: 'd'
15

2.3 删除字典元素

能删单一的元素也能清空字典，清空只需一项操作

显式删除一个字典用del命令

#删除指定的键
d = dict(a=1, b=2, c=3)
del d['a']
print(d)

{'b': 2, 'c': 3}

#删除指定的键，并且返回其值
d = dict(a=1, b=2, c=3)
print(d.pop('c'))

3

#删除并返回最后一个键值对
d = dict(a=1, b=2, c=3)
print(d.popitem())

('c', 3)

#删除字典所以项
d = dict(a=1, b=2, c=3)
d.clear()
print(d)

{}

#删除字典
d = dict(a=1, b=2, c=3)
del d
print(d)

NameError: name 'd' is not defined

3.字典的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住

mydic = {'Name': 'jack', 'Age': 27, 'Name': 'karen'}
print (mydic['Name'])

karen

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表等就不行

注: python 中有四种可变类型

列表 list
字典dict
集合 set
字节数组 bytearray

字典是可迭代对象, 字典只能对所有的键进行迭代访问，默认访问键

可以使用 for 循环来遍历字典的键和值。可以使用 dict.keys() 方法遍历键，使用 dict.values() 方法遍历值，使用 dict.items() 方法同时遍历键和值。

my_dict = {'a':1, 'b':2, 'c':3}
for key in my_dict:
    print(key, my_dict[key])


a 1
b 2
c 3

4.字典常用API

序号	函数	描述
1	len(dict)	计算字典元素个数，即键的总数。
2	str(dict)	输出字典，可以打印的字符串表示。
3	type(variable)	返回输入的变量类型，如果变

1	dict.clear()删除字典内所有元素
2	dict.copy()返回一个字典的浅复制
3	dict.fromkeys(seq)创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值，如果未提供，则所有键的值将被设置为 `None`
4	dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5	key in dict如果键在字典dict里返回true，否则返回false
6	dict.items()以列表返回一个视图对象
7	dict.keys()返回一个视图对象
8	dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2)把字典dict2的键/值对更新到dict里
10	dict.values()返回一个视图对象
11	pop(key,default)删除字典 key（键）所对应的值，返回被删除的值。
12	popitem()返回并删除字典中的最后一对键和值。

org_data = dict(a=3,b=[12,13,14],c=5)
cp_data = org_data.copy()
org_data['b'].append(15)
org_data['a']=4
print(org_data)
print(cp_data)

# 修改原始字典中的可变对象
# 对于可变对象（如列表、字典），修改原始字典中的值会影响浅复制的字典，因为它们引用的是同一个对象
# 对于不可变对象（如整数、字符串、元组），修改原始字典中的值不会影响浅复制的字典。

{'a': 4, 'b': [12, 13, 14, 15], 'c': 5}
{'a': 3, 'b': [12, 13, 14, 15], 'c': 5}

key = ['a','b','c']
value = [1,2,3]
dic = dict.fromkeys(key,value)
print(dic)



{'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}

5.列表、元组、字典小结

列表和元组是有序的，字典的存储在Python3.7以后是有序的
列表、字典是可变的,元组是不可变的
字典的键索引速度快，列表的索引速度也快

4.集合set/ 固定集合 frozenset

集合是可变的容器，固定集合是不可变的集合
集合相当于只有键没有值的字典
集合是无序的不重复元素的存储结构
集合内的数据都是唯一的，不可变的

1.集合的创建

创建集合的方式

空集合 set()

非空集合用 {} 括起来，值用逗号分隔开

s = set()            # 用函数空集合
s = {1, 2, 3, 4}     # 创建非空集合的字面值
s = set(range(5))    # 调用 set(可迭代对象) 来创建集合 s = {0, 1, 2, 3, 4}
s = set("ABC")       # s = {'B', 'C', 'A'}
s = set("ABCCCCCCC")  # s = {'B', 'C', 'A'}
s = set(['ABC'])      # s = {'ABC'} 使用 set()函数从列表创建集合
s = set((4, 5, 6, 7))# 使用 set()函数从元组创建集合




#创建固定集合frozensets的方式

fs = frozenset()              # 空固定集合 fs = frozenset()
fs = frozenset([1, 2, 3])     # fs =  frozenset({1, 2, 3})

2.集合的数据操作（增、删）

2.1 添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

s.add( x ) 添加元素到集合

s.update( x ) 添加元素到集合，且参数可以是列表，元组，字典等 ,x 可以有多个，用逗号分开

s1 = set((1,2,3))
print(s1)
s1.add(4)
s1.update([4,5,6])
print(s1)


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

2.2 删除元素

s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard( x ))：将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。

s.pop())：对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

s1 = set((3,2,9,4))
s1.remove(4)
s1.discard(5)
print(s1)
s1.pop()
print(s1)



{9, 2, 3}
{2, 3}

注意：集合（set）没有索引查看的功能。集合是一种无序、不可重复的数据结构，用于存储唯一的元素。由于集合是无序的，所以不能通过索引来访问其中的元素。所以也没有对应的修改功能

3.集合内置方法常用API

集合的方法

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集，返回一个新集合
difference_update()	移除集合中的元素，该元素在指定的集合也存在。直接修改第一个集合
discard()	删除集合中指定的元素
intersection()	返回集合的交集，返回一个新集合
intersection_update()	返回集合的交集。直接修改第一个集合
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素
len()	计算集合元素个数

5.Python推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

Python 支持各种数据结构的推导式：

列表(list)推导式
字典(dict)推导式
集合(set)推导式
元组(tuple)推导式

1.列表推导式

作用

用简单的表达式方式来创建列表
语法规则

[ 表达式 for 自定义变量 in 可迭代对象 ]
# 或
[ 表达式 for 自定义变量 in 可迭代对象 if 真值表达式 ]

l = [x*2 for x in range(10)]
print(l)


[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

2.字典推导式

字典推导基本格式：

{ 键表达式: 值表达式 for 元素 in 集合 }
{ 键表达式: 值表达式 for 元素 in 集合 if 条件 }

# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
lis = ['lisi','zhangsan','lisa']
dic = {key:len(key) for key in lis}
print(dic)


{'lisi': 4, 'zhangsan': 8, 'lisa': 4}

3.集合推导式

集合推导式基本格式：

{ 表达式 for 元素 in 序列 }
{ 表达式 for 元素 in 序列 if 条件 }

#计算数字 1,2,3 的平方数：

se1 = {key**2 for key in (1,2,3)}
print(se1)


{1, 4, 9}

4.元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

元组推导式基本格式：

（表达式 for 元素 in 序列）
（表达式 for 元素 in 序列 if 条件）

#生成一个包含数字 1~9 的元组
tu = (v for v in range(1,10))
print(tuple(tu))


(1, 2, 3, 4, 5, 6, 7, 8, 9)