[Python知识库]python学习——Day4

序列数据结构

1. 成员是有序排列的
2. 每个元素的位置称为下标或索引
3. 通过索引访问序列中的成员
4. python中序列数据类型有：字符串、列表、元组
   创建列表和元组
   python中的列表和元组，可以存放不同类型的数据。
   · 列表（list）：使用方括号[]表示。[1,2,3]
   · 元组（tuple）:元组使用小括号（）表示(1,2,3)

#创建列表和元组
lst_1=[1,2,3]
lst_2=[4]
lst_3=[[1,2,3],[4,5,6]]
lst_mix=[160612,"张明",18,[92,76,85]]
lst_empty=[]
print(lst_1,lst_2,lst_3,lst_mix,lst_empty)

[1, 2, 3] [4] [[1, 2, 3], [4, 5, 6]] [160612, '张明', 18, [92, 76, 85]] []

` 元组和列表的区别是：在列表中元素的个数和元素的值可以改变；但在元祖中，一经定义，元组的内容不能改变。（可以理解成元组是只读的列表）

#创建元组
tup_1=(1,2,3)
tup_empty=()
print(tup_1,tup_empty)

(1, 2, 3) ()

#只含有一个元素的元组的表示方法
t1=(1)   #这样写会有歧义，这是因为小括号既可以表示元组，又可以表示数学运算中的小括号，因此，python规定，这种形式按小括号进行计算，计算结果为1
t2=(1,)  #在表示只含有一个元素的元组时，通常用这种表示方法，在一个元素后面加一个逗号
print("t1=",t1,type(t1))
print("t2=",t2,type(t2))

t1= 1 <class 'int'>
t2= (1,) <class 'tuple'>

可以看到t1是一个数学表达式，结果是一个整数，t2是一个元组。
索引
索引是有方向的，正向索引是从左到右从0开始依次加1，逆向索引时从右到左从0开始依次减1。

#字符串索引
str_py="Python"
print(str_py[0])
print(str_py[-1])

P
n

#列表索引
lst_1=[1,2,3]
print(lst_1[1])
print(lst_1[-2])

2
2

切片
[开始位置：结束位置]
切片也是左闭右开的，其诶按不包括结束位置的元素。
切片的作用是：一次性从序列中获取多个元素，得到序列的子集
切片的定义中可以省略：

1. 开始位置省略，从序列中第一个元素开始
2. 结束位置省略，取到序列中的最后一个元素

#字符串切片
str_py="Python"
print(str_py[1:5])
print(str_py[1:])
print(str_py[:5])

ytho
ython
Pytho

#列表切片
list1=[1,2,3]
list1[2:]

[3]

#列表切片
lst_stud=[160612,"张明",18,[92,76,85]]
lst_stud[1:]

['张明', 18, [92, 76, 85]]

#列表切片
lst_stud=[160612,"张明",18,[92,76,85]]
lst_stud[:3]

[160612, '张明', 18]

#如果开始位置和结束位置都缺省了，那就是输出整个列表
lst_stud=[160612,"张明",18,[92,76,85]]
lst_stud[:]

[160612, '张明', 18, [92, 76, 85]]

打印
print（序列数据结构名称）————输出整个序列

#打印整个列表
lst_1=[1,2,3]
print(lst_1)
#打印整个元组
tup_1=(1,2,3)
print(tup_1)

[1, 2, 3]
(1, 2, 3)

获取序列的长度——len(序列名称)

#获取字符串的长度
len("Python")
str="Python"
len(str)

6

#获取字符串的长度
str="Python"
len(str)

6

#获取列表的长度
lst_1=[1,2,3]
len(lst_1)

3

#获取二维列表的长度
lst_3=[[1,2,3],[4,5,6]]
len(lst_3)

2

#获取混合列表的长度
lst_mix=[160612,"张明",18,[92,76,85]]
len(lst_mix)

4

#获取元组的长度
tup_1=(1,2,3)
len(tup_1)

3

更新列表：向列表中添加元素
` append()

#向列表中追加元素
lst_1=[1,2,3]
lst_1.append(4)
lst_1

[1, 2, 3, 4]

` 也可以使用insert（）函数向列表中指定位置追加元素

#向列表中追加元素
lst_1=[1,2,3]
lst_1.insert(1,5)    #其中第一个参数是指定位置，第二个参数是要插入的元素
lst_1

[1, 5, 2, 3]

更新列表：合并列表
extend()

#合并列表
lst_1=[1,2,3]
lst_2=[4]
lst_1.extend(lst_2)
lst_1

[1, 2, 3, 4]

合并列表也可以使用合并运算符“+”

#合并运算符“+”
lst_1=[1,2,3]
lst_2=[4]
lst_3=lst_1+lst_2   #采用这种方式时，lst_1和lst_2列表中的值并没有发生改变
lst_3

[1, 2, 3, 4]

更新列表：删除列表中的元素
del语句

#用del语句删除下标为1的元素
lst_1=[1,2,3,4]
del lst_1[1]    #删除下标为1的元素
lst_1

[1, 3, 4]

更新列表：排序
sort（）：对列表中的元素排序
reverse（）：对列表中的元素倒排序

lst_1=[2,3,1,4]
lst_1.sort()   #将lst_1中的元素按从小到大的顺序排列
lst_1

[1, 2, 3, 4]

lst_1=[2,3,1,4]
lst_1.reverse()   #将lst_1中的元素原地逆序
lst_1

[4, 1, 3, 2]

元组一经定义后不能更改，因此元组不支持更新操作

遍历列表中的元素

#遍历列表中的元素
lst_1=[1,2,3,4]
for i in lst_1:
    print(i,end=" ")

1 2 3 4

字典和集合

· 字典
每个字典元素都是一个键/值对
键：关键字
值：关键字的取值
例如：
语文：80；数学：85
字典是一种表示映射关系的数据结构

· 创建字典
{键：值，键：值，…}

#创建字典
dic_score={"语文":80,"数学":85,"英语":78,"体育":90}
dic_employ={"name":"Mary","age":26}
dic_empoly={"name":{"first":"Mary","last":"Smith"},"age":26}

· 打印字典、访问字典中的元素

#创建字典
dic_score={"语文":80,"数学":85,"英语":78,"体育":90}
dic_employ={"name":"Mary","age":26}
dic_empoly={"name":{"first":"Mary","last":"Smith"},"age":26}
print(dic_score)
print(dic_score["语文"])
len(dic_score)    #同样，使用len函数也可以查看字典的长度

{'语文': 80, '数学': 85, '英语': 78, '体育': 90}
80
4

· 判断字典是否存在元素——in运算符

#用in运算符判断字典中是否存在元素
dic_student={'name':'张明','sex':'男','age':'18','score':98}
'sex' in dic_student

True

· 遍历字典元素
keys():返回字典中所有的关键字
values():返回字典中所有的值
items():返回字典中所有的键值对

#遍历字典中所有的键
dic_student={'name':'张明','sex':'男','age':'18','score':98}
for key in dic_student.keys():
    print(key,end=" ")

name sex age score

字典中各个元素是无序的，因此每次打印出的结果可能出现不同的顺序。

#遍历字典中所有的值
dic_student={'name':'张明','sex':'男','age':'18','score':98}
for value in dic_student.values():
    print(value,end=" ")

张明 男 18 98 

#遍历字典中所有的键值对
dic_student={'name':'张明','sex':'男','age':'18','score':98}
for item in dic_student.items():
    print(item)

('name', '张明')
('sex', '男')
('age', '18')
('score', 98)

#格式化输出
for key,val in dic_student.items():
    print("dic_student[%s]="%(key),val)

dic_student[name]= 张明
dic_student[sex]= 男
dic_student[age]= 18
dic_student[score]= 98

更新字典：添加元素、修改指定元素的取值

#更新字典
dic_student={'name':'张明','sex':'男','age':'18'}
dic_student['score']=98
print(dic_student)
dic_student['score']=90
print(dic_student)

{'name': '张明', 'sex': '男', 'age': '18', 'score': 98}
{'name': '张明', 'sex': '男', 'age': '18', 'score': 90}

· 合并字典：将另一个字典中的元素追加到字典中

#合并字典
dic_student={'name':'张明','sex':'男','age':'18'}
dic_contact={'tel':'13104415887','email':'zhm@gmail.com'}
dic_student.update(dic_contact)
print(dic_student)

{'name': '张明', 'sex': '男', 'age': '18', 'tel': '13104415887', 'email': 'zhm@gmail.com'}

·删除字典中的元素

1. pop（指定元素的关键字）
2. clear（）
3. del 语句

#删除字典中的元素
dic_student={'name':'张明','sex':'男','age':'18'}
dic_student.pop('sex')
print(dic_student)
dic_student.clear()
print(dic_student)

{'name': '张明', 'age': '18'}
{}

· 集合（set）：由一组无序排列的元素组成
可变集合（set）
不可变集合（frozenset）
eg:{1,2,3,4,5,4,5}

#集合
set1={1,2,3,4,5,4,5}
print(set1)
len(set1)

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

` 创建集合
set()函数创建可变集合或frozenset()函数创建不可变集合

#创建集合
set_2=set('Python')
print(set_2)

{'y', 'P', 't', 'n', 'o', 'h'}

set_3=frozenset('Python')
print(set_3)

frozenset({'y', 'P', 't', 'n', 'o', 'h'})

集合中的元素是无序的，因此不能通过下标来访问。