Day6 列表元组和数字总结

列表的相关操作

1.运算符

1）数学运算符：+,*

列表1 + 列表2 -> 产生一个新的列表,新列表中的元素是两个列表中所有元素的合并

list1 = [1, 2, 3]
list2 = ['张三', '李四']
print(list1 + list2)

列表 * N / N *列表 - > 列表中的元素重复N次 产生一个新的列表

print(list1 * 3)

2）比较运算符：

==,!=
列表1 == 列表2 ->判断两个列表的值是否相等

list3 = [1, 2, 3]
list4 = [2, 1, 3]
print(list4 == list3)  # False

list4 = [1, 2, 3]
print(list4 == list3)  # True

is
变量1 is 变量2 -> 判断地址是否相等

li1 = [1, 2]
li2 = [1, 2]
print(li1 == li2)
print(li1 is li2)  # print(id(li1) == id(li2))

,<,>=,<=(了解)

print([1, 2, 3] > [10, 20])  # False 用第一个元素和第一个元素相比 比到能比较出大小为止
print("===============in/not in ==============")

2. in和not in

元素 in 列表 -> 判断列表中是否存在指定元素
元素 not in 列表 ->判断列表中是否不存在指定元素

names = ['小明', "小花", "小红", "张三"]
print("小红" in names)  # T
print("小" in names)  # F
print(["小明"] in names)  # F
print("====================相关函数============")

3.相关函数:len/max/min/list/sum

1)len(序列) - 获取序列的长度（元素的个数）

print(len([1, 2, 3]))
print(len("Hello"))

2)max/min(序列)

功能：获取序列元素的最大值和最小值
要求：a.序列中的数据类型要一致（但是数字是一个类型）
b.元素本身支持比较大小的运算符

x = 0
scores = [23, 4, 56, 75, 32, 43, 21, 45, 67]
print(max(scores))  # 75
print(min(scores))  # 4

scores = ["100", 12]
# print(max(scores))  # '>' not supported between instances of 'int' and 'str' 类型不同报错

3）sum

sum(数字序列) ->求序列中所有元素的和

scores = [1, 2, 3]
print(sum(scores))
print(sum(range(101)))

4)list

list(数据) -> 将制定的数据转换为列表；数据必须是序列（所有的序列都可以转换为列表）
print(list(1)) TypeError: 'int' object is not iterable

print(list('hello'))
print(list(range(10, 15)))

列表的相关方法

1.列表.count(元素） ->统计列表中指定元素的个数

names = ["赵云", "小乔", "貂蝉", "吕布", "诸葛亮", "司马懿", "小乔"]

print(names.count("小乔"))  # 2
print(names.count("大乔"))  # 0

2.列表.extend(序列） - 将序列中的元素全部添加到列表中

names.append("后羿")  # ['赵云', '小乔', '貂蝉', '吕布', '诸葛亮', '司马懿', '小乔', '后羿']
print(names)  # append 是增加一个元素加进去
names.extend('后羿')  # ['赵云', '小乔', '貂蝉', '吕布', '诸葛亮', '司马懿', '小乔', '后羿', '后', '羿']
print(names)  # extend是把东西拆开 最为一个一个元素加进去 把后面的列表加到第一个去

3.列表.index(元素） -> 获取指定元素在列表中的下标 （0~长度-1）

a.如果元素不存在 报错

nums = [10, 3, 50, 3, 90]
# print(nums.index(100))    ValueError: 100 is not in list

b.如果元素有多个

print(nums.index(3))  # 1 显示第一个

4.列表.reverse() -> 将原来的列表倒序（反过来）

nums = [1, 9, 3]
nums.reverse()
print(nums)  # 该方法将改变原有序列
new_nums = nums[::-1]  # 创建新的 原有不变

5.列表.clear() ->清空列表

nums = [1, 9, 3]
nums.clear()  # 这种方法优于直接赋值
print(nums)
# 注意：清空列表用clear
nums = [1, 9, 3]
nums = []
print(nums)

6.列表.copy()

->复制列表中的元素产生一个新的列表 将新列表的地址返回 赋值后两个互不影响
和列表[:]功能一模一样 都属于浅拷贝

heros = ['后羿', '甄姬', '凯', "庄周", '蔡文姬']
heros2 = heros  # 直接赋值，赋值后两个列表相互影响
del heros[-1]
print(heros2)

7.列表.sort()

-> 将列表中的元素从小到大排序（直接修改列表元素的顺序，不会产生新的列表）
列表.sort(reverse = True） -> 将列表的元素从大到小（原列表上修改）
其实就是等于 列表.sort();列表.reverse()

scores = [23, 12, 4, 5, 67, 86, 43]
scores.sort()
print(scores)

scores = [23, 12, 4, 5, 67, 86, 43]
scores.sort(reverse=True)
print(scores)

8.排序函数：sorted（序列）

-> 不修改原序列 排序后产生一个新的列表（返回值是列表） 从小到大 升序
sorted（序列，reverse=True）-> 不修改原序列，排序后产生一个全新的列表，（从大到小 降序）

scores = [23, 12, 4, 5, 67, 86, 43]
new_sco = sorted(scores)
print(scores)   #  [23, 12, 4, 5, 67, 86, 43]
print(new_sco)  # [4, 5, 12, 23, 43, 67, 86]

str1 = "hello"
new_str1 = sorted(str1)
print(new_str1)   # ['e', 'h', 'l', 'l', 'o']

# reversed（序列） -》 将序列中的元素倒序，产生一个新的序列对应的迭代器（了解）
# new_str2 = reversed("abc")
# str2 = ""
# for x in new_str2:
#     str2 += x
# print(str2)

遍历删除的坑

# 坑一：直接遍历元素删除满足条件的元素 -> 因为遍历的时候列表的元素取不完 导致删不干净
socres = [23, 45, 6, 78, 65, 98, 99, 43, 55, 32]
for num in socres:
    print(num)
    if num < 60:
        socres.remove(num)
print(socres)

"""
socres = [23, 45, 6, 78, 65, 98, 99, 43, 55, 32]
num = 23: 23<60 -> [45, 6, 78, 65, 98, 99, 43, 55, 32]
num = 6: 6<60 ->[45, 78, 65, 98, 99, 43, 55, 32]
num = 65: 65 > 60 ->[45, 78, 65, 98, 99, 43, 55, 32]
...
循环结束：删过几个跳几次

"""

# 解决坑一：保证遍历过程中能够把需要删除的列表中的元素全部取完
socres = [23, 45, 6, 78, 65, 98, 99, 43, 55, 32]
# t_socres = socres.copy()
t_socres = socres[:]
for num in t_socres:
    print(num)
    if num < 60:
        socres.remove(num)
print(socres)

# 坑二：
# socres = [23, 45, 6, 78, 65, 98, 99, 43, 55, 32]
# length = len(socres)
# for index in range(length):
#     if socres[index] < 60:
#         del socres[index]
# print(socres)
socres = [23, 45, 6, 78, 65, 98, 99, 43, 55, 32]
index = 0
while index < len(socres):
    print(socres[index])
    if socres[index] < 60:
        del socres[index]
        continue
    #     index -= 1
    index += 1
print(socres)

元组

1.什么是元组（tuple）

元组就是不可变的列表
元组是容器型数据类型，将（）作为容器的标志，里面多个元素用，隔开。(元素1，元素2...)
元组不可变（不支持增删改操作），有序（支持下标操作）
元素可以是任何类型的数据

tuple1 = (1, 2, 3)
print(type(tuple1))
``
##2.和列表一样的操作
####1）获取元素
列表获取元素的操作，元组都支持
```python
tuple1 = (10, 30, 21, 70)
print(tuple1[-1])
print(tuple1[2:])  # (21, 70) 元组切片也是小的元组

2）相关运算：+，*，==，！=，is,in ,not in ,len,max,min,sum,sorted(排序后成为列表）【产生新序列】

print((1, 2) + ("abc", "hello"))
print()

tuple(数据) - 将数据转换为元组 该数据必须是序列
print(tuple1)

3.元组特有或者使用频率偏高的操作

1）单个元素的元组 （元素，）

list1 = [10]
print(list1, type(list1))
tuple3 = (10)
print(tuple3, type(tuple3))  # 10 
tuple3 = (10,)
print(tuple3, type(tuple3))

2）单独使用元组的值，（）可以省略 ->直接多个数据用逗号隔开表示的还是一个元组

tuple3 = 10, 20, 30
print(tuple3, type(tuple3))

3)可以通过让变量的个数和元组中元素的个数保持一致来分别获取元组中的元素

变量1，变量2，变量3 ...=元组

tuple5 = (10, 20)
x, y = tuple5
print(x, y)

x,y = 10,20   -> x,y = 10,20

4)同时声明多个变量获取元组中的元素，变量的个数可以比元组中的个数少，但是这个时候

多个变量中的某一个变量的前面必须加；带的变量可以获取不带*的变量获取完剩下的部分

tuple5 = (10, 20, 299, 19, 230)
*x1, x2, x3 = tuple5
print(x1, x2, x3) # [10, 20, 299] 19 230

x1, *x2, x3 = tuple5
print(x1, x2, x3) # 10 [20, 299, 19] 230

数字

import math  # 数学模块 提供数学相关方法和数据
import cmath  # 和复数相关的数学模块

python中和数字相关的类型：整形（int）、浮点型（float）、布尔（bool）和复数（complex）

1.整形（int） - 所有整数对应的类型（python2.x 整形除了int还有long）：支持2进制，8进制和16进制的表示方式

int(数据） - 将制定的数据转换为整数；
1）所有的浮点数和布尔都可以转为整型(就是转为整数部分）
2）字符串去掉引号后本身就是整数

print(int(-12.5)) # -12
print(int('123')) # 去掉引号后本身就是整数才可以转

2.浮点型（float） - 所有带小数点的数对应的类型；支持科学计数法：3e4 == 310*4

float（数据） - 将指定的整数转换为浮点数
1）所有的整数和布尔都可以转
2）字符串去掉引号后本身就是一个数字

print(float('2e3'))  # 2000.0

print(3e4)  # 30000.0
print(1e-5 + 1)  # 1.00001
print(7 / 8)

3.布尔（bool） - 只有True和False；True的本质就是1，False本质0

bool（数据） - 将制定数据转换为布尔值；
不管什么类型数据都能转为布尔，所有为0为空的值都是False其他都是True

print(bool(0), bool([]), bool(()), bool(None))
print(bool(' '))  # 空格也是True
list1 = [1, 2]
while list1:
    print("====")
    break

num = 10
if num & 1:
    print('奇数')

num = 10
if num & 1 == 0:
    print('偶数')

print(True == 1)  # True
print(True + 1)  # 2
print(False + 19)  # 19

4.复数（complex） - 有实部和虚部组成的数，实部+虚部j；直接支持复数的运算

注意：如果虚部是1，这个1不能省

c1 = 10 + 2j
c2 = 5 - 3j
print(c1 + c2)
print(c1 - c2)
print(c1 * c2)

5.数学模块

# math.pi
# math.floor()

print(math.fabs(-8)) # 求绝对值