1.列表的相关操作

列表1 + 列表2 - 将两个列表中的元素合并产生一个新的列表(不会修改原列表)
列表 * N 、N * 列表 --- N 是正整数；列表中的元素重复N次产生新的列表

1）加法运算

print([1, 2, 3] + [10, 20, 30])
list1 = [11, 22, 33]
print(list1 + [100, 200], list1)
# 乘法运算
print(list1 * 3)  #[11, 22, 33, 11, 22, 33, 11, 22, 33]

2) 乘法运算

print(list1 * 3)  #[11, 22, 33, 11, 22, 33, 11, 22, 33]

3).列表的比较运算: ==，！= , > , < , >=, < =

列表1 == 列表2 、 列表1 ！= 列表2
两个列表比较大小 ,比较第一个

list2 = [1, 2, 3]
list3 = [1, 2, 3]
print(list1 == list2)  # True
list3 = [1, 3, 2]
print(list1 == list3)  # False

补充: is 的用法

== -->是判断两个数据的值是否相等

is --> 判断两个数据的地址是否一样

print("++++++++++++++++")
list1 = [1, 2, 3]
list2 = [1, 2, 3]   # 相当于 id(list1) == id(list2)
print(list1 is list2)  # False
print([1, 2, 3, 4, 5] >[2 , 3]) # False 第一个元素比较 后面不比较

4).in 和 not in

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

print(60 in [1, 2, 3, 4])  # False
print(12 in [12, 356,56,9,65])  # True

5).内置函数 max(序列), min(序列) ,sum(序列), len(序列)

max 和 min 要求序列中的元素类型必须一致,并且元素 支持比较运算符
sum 要求序列中的元素必须是数字
list(序列) - 只有容器型数据类型才能转换成列表,将序列中的元素转换成一个新的列表

print(max([23, 45, 78, 90, 32, 45]))  # 90
print(min([10, 12, 60, 85, 32, 78]))  # 10
print(max(['小明', 'abc', '小花']))   # 小花
print(sum([23, 45, 78, 90, 32, 45]))  # 313

print(list('abc'))  # ['a', 'b', 'c']
print(list(range(5)))  # [0, 1, 2, 3, 4]

2.列表方法

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

nums = [23, 9, 60, 89, 60, 60, 1, 23, 60]

print(nums.count(60))

2).列表.extend(序列) -- 将序列中的元素添加到列表的最后

nums = [1, 2, 3]
nums.extend([10, 20])
print(nums)
nums.extend('hello')
nums.extend(range(100, 105))
print(nums)

3).列表.index(元素) -- 获取元素在列表中的下标 ,如果元素有多个,只取第一个

nums = [23, 9, 60, 89, 60, 60, 1, 23, 60]

print(nums.index(89))  # 3
print(nums.index(23))  # 0

4).列表.reverse() ---让列表倒叙(不会产生新的 列表)

nums = [23, 9, 60, 89, 60, 60, 1, 23, 60]
nums.reverse()
print(nums)

5).列表.sort()

列表.sort() - 将列表中元素从小到大排序
列表.sort(reverse = True) --将列表中的元素从大到小排序
注意 : 列表中的元素类型必须一样,并且元素支持比较运算符,不会产生新的列表

nums = [23, 9, 60, 89, 60, 60, 1, 23, 60]
nums.sort()
nums.sort(reverse=True)
print(nums)

6).内置函数:sorted(序列)

sorted(序列) - 对序列中的元素从小打到排序,产生一个新的序列
sorted(reverse = True) --对序列中的元素从大到小排序,产生一个新的序列

nums = [23, 9, 60, 89, 60, 60, 1, 23, 60]
new_nums = sorted(nums)
print(new_nums)

print(sorted('hello'))

6).清空列表

nums = [23, 9, 60, 89, 60, 60, 1, 23, 60]
nums.clear()
print(nums)

7).列表.copy() -- 和列表[:]的效果一样,拷贝列表中的元素产生一个新列表 这儿的拷贝是前拷贝

nums = [1, 2, 3]
new_nums = nums  # 直接赋值,赋的是地址
nums.append(100)
print(new_nums)

nums = [1, 2, 3]
new_nums2 = nums.copy()  # 拷贝赋值 ,赋的是新地址
nums.append(100)
print(new_nums2)

3.元祖

1).什么是元祖(tuple)

元祖是容器型数据类型(序列),将()作为容器的标准,多个元素用逗号隔开:(元素1, 元素2, 元素3)
特点: 不可变的(不支持增删改),有序的(支持下标操作)
元祖中元素 --- 和列表要求一样

1) .元祖的表示

tuple1 = ()
print(tuple1, type(tuple1))

tuple2 = ('abc',)
print(tuple2, type(tuple2))

2).单独表示一个元祖值的时候，小括号可以省略

tuple3 = 1, 2, 3, 4
print(tuple3, type(tuple3))

3).获取元祖中的元素

列表中获取元素的方式元祖都支持

weeks = '周一', '周二', '周三', '周四'

# 1)获取单个元素
print(weeks[1], weeks[-1])
# 2) 前面

print(weeks[1:4], weeks[1::2])
# ) 遍历
for week in weeks:
    print(week)
for index in weeks:
    print(week)
    print("----------------------")
for index in range(len(weeks)):
    print(index, weeks[index])

5)获取部分元素:变量一，变量2，变量3.... =元祖

用变量去获取元祖中元素的值(要求前面变量的个数和元祖的个数一样)

tuple4 = (10, 20, 30)
x, y, z = tuple4
print(x, y, z)

a, b, c = 1, 2, 3  # a,b,c=(1,2,3)
a1, a2 = [10, 20]
print(a1)

5).语法 -- 多个变量某一个变量前带 = 元祖

让不带 * 的变量去元祖中获取元素， 剩下的全部给带 * 的变量 (带*的变量会变成列表)

student = ('小明', 18, 'stu001', 23, 89, 90, 89)
name, age, study_id, *scores = student
print(name, age, study_id, scores)

*x, y, z = student
print(x, y, z)  # z = 89, y = 90 x = ['小明', 18, 'stu001', 23, 89]
```python
 ##6).元祖相关的操作 : 和列表一样
tuple8 = 1, 2, 3
tuple5 = 2, 3, 4
# +,*,==,!=,in,not in, max,min,sum,tuple,len,sorted
x = len(tuple8)
print(x)

3 数字

1).整型

所有的整数对应的类型就是整型, python 3.x中整型对应的数据类型只有int , python2.x除了int 还有long
int(数据) --> 将数据转换成整数. 所有的小数、布尔值和部分字符串可以转换成整数
字符串中只有去掉引导后本身就是一个整数的字符串才能转换成整型

print(int(3.14), int(3.99))
print(int(True), int(False))
print(int('45'))
print(int('+100'), int('-123'))  # int("12.5") 不能转化
print(int())  # 0
print(list(), tuple()) #[] ,()

2).浮点型

所有的小数对应的类型就是浮点型，浮点型对应的数据类型只有float，支持科学计数法 3e4 = 3 * 10 ** 4
float(数据) --整型，布尔和部分字符串可以转换成浮点型
字符串中只有去掉引导后本身就是一个数字的字符串才能转换成浮点型

print(3e4)  # 30000.0
print(1.25e2)  # 125.0

print(float(100))  # 100.0
print(float(True), float(False))   # 1.0   0.0

print(float('23'))  # 23.0
float('23.8')  # 23.8

3).布尔

布尔中的True本质是整数1，False本质是整数0

bool(数据) - 所有的数据都可以转换成布尔; 所有为0为空的值都会转化成False,其他的都是True

print(1+1, True+1, True*10, True/10)  # 2 2 10 0.1
print(bool(0), bool(0.0), bool(''), bool([]), bool(None), bool({}))

num = 10
if not num % 2:
    print('偶数')
if num % 2:
    print("奇数")

4).复数

由实部和虚部组成的数字叫复数 ：a + bj(a 是实部、b是虚部、j是虚数单位)

a = 10 + 20j
print(a, type(a))
b = 10 + 1j  # 虚部是1不能省略
c = 10j
print(b, c)

num1 = 2 + 3j
num2 = 4 - 2j
print(num1 + num2)  # 6 + 1j
print(num1 * num2)  # (14 + 8j)
print(num1 / num2)  # (01 + 0.8j)

4.random

1)python 内置了一个模块叫random，提供了和随机操作的相关方法

random.randint(m,n) -产生M-N的整数

print(random.randint(0, 10))

2)random.random() 产生0-1的随机数(小数)

print(random.random())

3)random.randrange(M, N, step) --产生range(M,N,step)中任意一个数

print(random.randrange(0, 100, 2))

4)random.choice(序列,k = N) --在序列中随机获取N个元素，以列表的形式返回 N默认是1

names = ['小明', '张三', '李四', '小花', 'tom']
print(random.choices(names, k=2))

5)random.shuffle 随机打乱元素表的位置

random.shuffle(names)
print(names)