python第三章

python第三章

list(列表)

假如 我们要存储5个人的年龄，求他们的平均年龄

age1 = 15
age2 = 16
age3 = 17
age4 = 18
age5 = 19

print((age1+age2+age3+age4+age5)/5)

运行结果得：

17.0

那么问题来了 ，如果说我需要存储100个人的年龄，并且也要求他们的平均年龄

解决办法：使用列表

列表本质：是一种有序的集合

创建列表

格式： 列表名 = [列表选项1, 列表选项2, ……, 列表选项n]

# 创建空列表
list1 = []

# 创建带有元素的列表
# 列表中的元素的数据类型可以不同
list2 = [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, "good", True, None]

列表元素的访问

list3 = [18, 19, 20, 21, 22]
# 取值：列表名[下标]
print(list3[2])
# 替换：列表名[下标] = 新值
list3[2] = 200
print(list3)
# 注意：下标不要越界
# print(list3[5])
# list3[5] = 23
# print(list3)

列表操作

# 列表组合
list4 = [1,2,3]
list5 = [4,5,6]
print(list4, list5)
print(list4 + list5)
# 列表重复
list6 = [7,8,9]
print(list6 * 3)
# in        not in
print(1 in [1,2,3])
# 列表截取(切片)
list7 = [1,2,3,4,5,6,7,8,9,0]
print(list7[2])
print(list7[1:4])
# -1表示的是最后一个元素的下标， -2倒数第二个元素的下标
print(list7[1:-1])
print(list7[4:])
print(list7[:4])

二维列表

含义：列表中元素是一维列表

本质：一维列表

list8 = [[1,2,3],
         [4,5,6],
         [7,8,9]]
print(list8)
print(list8[1][1])

列表方法

# append(obj)
# 在列表的末尾添加一个新的元素
list1 = [1,2,3,4,5]
list1.append([9,8,7])
print(list1)

# extend(seq)
# 在列表末尾一次性追加多个元素
list2 = [1,2,3,4,5]
list2.extend([9,8,7])
print(list2)

# insert(index, obj)
# 将元素出入列表，不会覆盖原元素，原元素按顺序后移
list3 = [1,2,3,4,5]
list3.insert(2, 100)
print(list3)

# pop(obj=list[-1])
# 移除列表中指定下标处的元素，默认删除最后一个元素
list4 = [1,2,3,4,5]
list4.pop()
# list4.pop()
print(list4)

# remove(obj)
# 移除列表中的某个值的第一个匹配项
list5 = [1,2,3,4,5,3]
list5.remove(3)
print(list5)

# clear()
# 清空列表
list6 = [1,2,3,4,5,3]
list6.clear()
print(list6)

# index(obj)
# 从列表中找出某个值第一个匹配项的下标
list6 = [1,2,3,4,5,3]
print(list6.index(3))

# len(list)
# 返回列表中元素的个数
list7 = [1,2,3,4,5,3]
print(len(list7))

# count(obj)
# 统计某个元素在列表中出现的次数
list7 = [1,2,3,4,5,3]
print(list7.count(3))

# max(list)
# 返回列表中元素的最大值

# min(list)
# 返回列表中元素的最小值

# reverse()
# 倒序列表中元素
list8 = [1,2,3,4,5,3]
list8.reverse()
print(list8)

# sort([func])
list9 = [4,7,1,3,9,5]
list9.sort()
list9.reverse()
print(list9)

# list(seq)
# 转为列表  字符串、元组、集合
print(list("sunck"))

# copy()
# 拷贝

浅拷贝与深拷贝

from copy import copy, deepcopy
'''
==：判断的是值
is：判断的是内存地址
'''
# num1 = 300
# num2 = 300
# print(id(num1), id(num2))
# print(num1 == num2)
# print(num1 is num2)

小整数对象

小整数对象：[-5, 256]

最好在python环境中演示，pycharm进行了其他的优化

# a = [1,2,3,4,5,[7,8,9]]
# b = a
# print(b == a)
# print(b is a)
# a[5][1] = 100
# print(a, b)
# print(id(a), id(b))
# print(id(a[5]), id(b[5]))

a = [1,2,3,[4,5,6]]
#深浅拷贝的区分的前提是列表中要有其他列表
#浅拷贝：只拷贝表层元素
# copy
b = copy(a)


#深拷贝：在内存中重新创建所有子元素
# deepcopy
c = deepcopy(a)

a[0] = 100
print(a, b, c)

# print(b == a)
# print(b is a)
# print(c == a)
# print(c is a)
# print(id(a[1]), id(b[1]), id(c[1]))
# print(id(a), id(b), id(c))
# print(id(a[3]), id(b[3]), id(c[3]))
# print(id(a[3][1]), id(b[3][1]), id(c[3][1]))

tuple(元组)

本质：是一种有序集合

特性：

​ 1、与列表非常类似

​ 2、一旦初始化就不能修改

​ 3、使用小括号

创建元组

元组名 = (元组选项1, 元组选项2, ……, 元组选项n)

创建空元组

t1 = ()
print(t1)
# 定义带元素的元组
# 元素类型可以不同
t2 = (1,2,3,4,5,"good")
print(t2)
# 定义含有一个元素的元组
# 注意：加个逗号
t3 = (1,)
print(t3)

元组元素的访问

#取值  元组名[下标]
t4 = (1,2,3,4,5)
print(t4[1])
# print(t4[5]) #下标越界
print(t4[-1])
print(t4[-5])
# print(t4[-6])  # 下标越界
#修改元组,元组的元素不能修改，但是元素如果是个列表那么可以修改这个列表
t5 = (1,2,3,4,5,[6,7,8])
# t5[5] = [8,7,6]
t5[5][1] = 100
print(t5)

元组的操作

#元祖的组合
t6 = (1,2,3)
t7 = (4,5,6)
print(t6 + t7)
#元组重复
print(t6 * 3)
# 元组截取（切片）
# 与列表、字符串向类似
t8 = (1,2,3,4,5,6,7,8,9)
print(t8[2:7])

元组的方法

# len(tuple)
# 返回元组的元素个数
t9 = (1,2,3)
print(len(t9))

# max(tuple)
# min(tuple)

# tuple(seq)
# 将集合转为元组
l = [1,2,3,4,5,6]
t10 = tuple(l)
print(t10)

条件控制语句

• if语句
• if-else 语句
• if-elif-else语句

格式：

if 表达式1:
    语句1
elif 表达式2:
    语句2
...........
elif 表达式n:
    语句n
else:
    语句e

逻辑：当程序执行到if-elif-else语句时，首先计算“表达式1”的值，如果“表达式1”的值为真，则执行“语句1”，执行完“语句1”则结束整个if-elif-else语句继续向下执行。如果“表达式1”的值为假，则计算“表达式2”的值，如果“表达式2”的值为真，则执行“语句2”，执行完“语句2”则结束整个if-elif-else语句继续向下执行。如果“表达式2”的值为假，则计算“表达式3”的值。如此进行下去，直到某个表达式的值为真为止。如果所有的表达式都为假，且有else语句则执行“语句e”

从该控制台输入一个年龄

小于0 输入有误
0~1 婴儿
2~6 幼儿
7~14 儿童
15~18 少年
19~30 青年
31~40 壮年
41~50 中年
51~150 老年
151~ 妖精

age = int(input("输入一个年龄:"))
if age <= 0:
    print("输入错误")
if  age > 0 and age <= 1:
    print("婴儿")
if  age >= 2 and age <= 6:
    print("幼儿")
if  age >= 7 and age <= 14:
    print("儿童")
if  age >= 15 and age <= 18:
    print("少年")
if  age >= 19 and age <= 30:
	print("青年")
if  age >= 31 and age <= 40:
    print("壮年")
if  age >= 41 and age <= 50:
    print("中年")
if  age >= 51 and age <= 150:
    print("老年")
if  age > 150:
    print("妖怪")

• if-else 语句

if age <= 0:
    print("输入错误")
elif  age > 0 and age <= 1:
    print("婴儿")
elif  age >= 2 and age <= 6:
    print("幼儿")
elif  age >= 7 and age <= 14:
    print("儿童")
elif  age >= 15 and age <= 18:
    print("少年")
elif  age >= 19 and age <= 30:
    print("青年")
elif  age >= 31 and age <= 40:
    print("壮年")
elif  age >= 41 and age <= 50:
    print("中年")
elif  age >= 51 and age <= 150:
    print("老年")
else:
    print("妖怪")

• if-elif-else语句

if age <= 0:
    print("输入错误")
elif  age <= 1:
    print("婴儿")
elif  age <= 6:
    print("幼儿")
elif  age <= 14:
    print("儿童")
elif  age <= 18:
    print("少年")
elif  age <= 30:
    print("青年")
elif  age <= 40:
    print("壮年")
elif  age <= 50:
    print("中年")
elif  age <= 150:
    print("老年")
else:
    print("妖怪")

循环语句while

格式：

while 表达式:

    语句

逻辑：当程序执行到while语句时，首先计算表达式的值，如果表达式的值为假，则跳过整个while语句继续向下执行。如果表达式的值为真，则执行语句，执行完语句再计算表达式的值。如果表达式的值为假，则跳过整个while语句继续向下执行。如果表达式的值为真，则执行语句，执行完语句在计算表达式的值，如此循环往复直到表达式的值为假才停止。

打印5句hello world

index = 0
while index < 5:
    print("hello world")
    index += 1

运行结果：

hello world
hello world
hello world
hello world
hello world

求1+2+3+……+100的和

index = 1
sum = 0
while index <= 100:
    sum = sum + index
    index += 1
print("sum = %d"%sum)

运行结果：

sum = 5050

死循环：表达式永远为真的循环

while 1:
    print("hello world!")

使用while-else语句

格式：

while 表达式:
    语句1
else:
    语句2 

**逻辑：**在表达式的值为False时执行else语句中的语句2

a = 1
while a < 5:
    print("This is an apple.")
    a += 1
else:
    print("This is a banana.")

循环语句 for

格式：

for 变量 in 集合:
    语句

**逻辑：**当程序执行到for语句时，按顺序取“集合”中的每个元素赋值给“变量”，在执行“语句”。如此循环往复，直到取完集合中的元素为止。

for x in [1,2,3,4,5]:
    # print("x = %d"%x)
    print("This is an apple.")

运行结果：

This is an apple.
This is an apple.
This is an apple.
This is an apple.
This is an apple.

列表生成器

# range([startNum,]endNum[, step])
# startNum：开始的数字，默认为0
# endNum：结束的数字，不包含在内
# step: 步长，默认为1
# [1,2,3,4,5]
for x in range(1, 6):
    print("x = %d"%x)

运行结果：

x = 1
x = 2
x = 3
x = 4
x = 5

求1+2+3+……+100的和

sum = 0
for i in range(1, 101):
    sum += i
print("sum = %d"%sum)

运行结果：

sum = 5050

同时遍历下标和元素

for index, x in enumerate([1,2,3,4,5]):
    print(index, x)

运行结果：

0 1
1 2
2 3
3 4
4 5

pass语句

作用：当语句要求不希望任何命令或代码来执行

说明：pass语句时一个空操作，在执行时没有任何响应。pass也是代码最终会用的，但是暂时写不出来

使用在 if语句、while语句、for语句、函数、类等位置

if 1:
    pass
for x in [1,2,3]:
    pass

break

作用：跳出循环

注意：只能跳出距离最近的for或者while

for x in [1,2,3,4,5]:
    if x == 3:
        break
    print("x = %d"%x)
print("-------------------")
for m in [1,2,3,4,5]:
    print("m = %d"%m)
    for n in [1,2,3,4,5]:
        if n == 3:
            break
        print("n = %d"%n)

循环语句可以有else语句，表达式错误导致循环终止时被执行，但循环被break终止时else语句不执行

index = 0
while index < 3:
    print("index = %d"%index)
    index += 1
    if index == 1:
        break
else:
    print("循环结束了")
    print("---------------------------------")

continue

作用：跳过本次循环快中的剩余语句，然后继续下一次循环

注意：只能跳过距离最近的for或者while

for x in [1,2,3,4,5]:
    if x == 3:
        continue
    print("x = %d"%x)
print("-------------------")

代码嵌套，层级要明确，嵌套最多在6、7层左右，最好3层

for m in [1,2,3,4,5]:
    print("m = %d"%m)
    for n in [1,2,3,4,5]:
        if n == 3:
            continue
        print("n = %d"%n)

dict(字典)

使用键-值对(key-value)的形式存储数据，具有极快的查找速度

可以的特性：

​ 1、字典中的key必须唯一

​ 2、key必须是不可变对象

​ a、字符串、整数等都是不可变的，可以作为key

​ b、列表时可变的，不能作为key

​ 3、key一般为字符串

保存一个学生的基本信息(姓名、性别、年龄、升高、体重)

stu1 = [“natasha”, “男”, 18, 188, 75]

stu2 = [“女”, “mary”, 48, 18, 177]

解决：使用字典

注意：字典中的键值对是无序的

# 创建字典存储一个学生的基本信息
# {key1:value,key2:value2,……,keyn:valuen}
stu1 = {"name": "natasha", "age": 18, "sex": "男", "height": 188, "weight": 75}
stu2 = {"name": "mary", "age": 18, "sex": "女", "height": 177, "weight": 48}
stus = [stu1, stu2]
print(stu2)

运行结果：

{'name': 'mary', 'age': 18, 'sex': '女', 'height': 177, 'weight': 48}

#元素的访问
stu3 = {"name": "mary", "age": 18, "sex": "女", "height": 177, "weight": 48}
#获取    字典名[key]    字典.get(key)
print(stu3["name"])
# print(stu3["score"]) #获取的键不存在会报错
score = stu3.get("score")
if score:
    print("分数为：%.2f"%score)
else:
    print("学生没有这个属性")
    
#添加  如果键不存在则增加属性，否则覆盖原数据
stu3["socre"] = 99.99
stu3["height"] = 180
print(stu3)

#删除
stu3.pop("socre")
print(stu3)

print("-----------------------")


#遍历
stu4 = {"name": "mary", "age": 18, "sex": "女", "height": 177, "weight": 48}
for key in stu4:
    print(key)
print("--------")
for value in stu4.values():
    print(value)
print("--------")
for key, value in stu4.items():
    print(key+": "+str(value))
print("--------")
for index, key in enumerate(stu3):
    print(index, key)

运行结果：

mary
学生没有这个属性
{'name': 'mary', 'age': 18, 'sex': '女', 'height': 180, 'weight': 48, 'socre': 99.99}
{'name': 'mary', 'age': 18, 'sex': '女', 'height': 180, 'weight': 48}
-----------------------
name
age
sex
height
weight
--------
mary
18
女
177
48
--------
name: mary
age: 18
sex: 女
height: 177
weight: 48
--------
0 name
1 age
2 sex
3 height
4 weight

比较list和dict

dict

​ 优点：查找和插入的速度极快，不会随着key的增多而降低效率

​ 缺点：需要占用大量的内存，内存浪费过多

list

​ 优点：占用内存空间小，浪费内存很少

​ 缺点：查找和插入的时间会随着元素的增加而增加

set

与dict类似，是一组key的集合(不存储value)

本质：无序和无重复的集合

#创建:需要用一个list或者tuple作为输入集合
# 注意列表中的重复元素会被过滤掉
s1 = set([1,2,3,4,5,3,4])
print(s1)
# 列表去重
numList = [1,2,3,5,7,8,3,5,6,8,9]
numList = list(set(numList))
print(numList)

#添加
s2 = set([1,2,3,4,5])
# 插入list、字符串、元组的每个元素
# iterable 可迭代对象
# s2.update("sunck")
# s2.update([6,7,8])
# s2.update((6,7,8))
# 不能直接插入数字
# s2.update(9)
print(s2)

#删除
s3 = set([1,2,3,4,5])
# 从左侧开始删除
print(s3.pop())
# 删除对应的元素，如果元素不存在会报KeyError的异常
s3.remove(3)
print(s3)

#遍历
s4 = set([6,2,3,4,5])
for key in s4:
    print(key)
print("------")
for index, key in enumerate(s4):
    print(index, key)

#交集与并集
s5 = set([1,2,3])
s6 = set([2,4,3])
# 交集
print(s5 & s6)
# 并集
print(s5 | s6)

运行结果：

{1, 2, 3, 4, 5}
[1, 2, 3, 5, 6, 7, 8, 9]
{1, 2, 3, 4, 5}
1
{2, 4, 5}
2
3
4
5
6
------
0 2
1 3
2 4
3 5
4 6
{2, 3}
{1, 2, 3, 4}

类型转换

list和tuple中的元素不能存在可变对象

list、tuple、string-->set
set()

tuple、set、string-->list
list()

list、set、string-->tuple
tuple()