Day6-Python数字和列表基础

1.数字和列表

Python中的数字类型: int(整型)、float(浮点型)、bool(布尔)、complex(复数)

1.1 int(整型)

所有整数对应的类型。（注意：在python2.x有long）

1.2 float(浮点型)

所有的小数对应的类型, 支持科学计数法：
print(3e4, 4e-2)

1.3 bool(布尔)

只有True和False两个值，其他 True 本质就是数字 1， False 本质是数字 0 。
print(1+1, True + 1, False + 1)

1.4 complex(复数)

包含实部和虚部的数就是复数，对应的数据类型是complex。
python 中表示复数的时候，虚数单位是 j； j前面如果是1，1不能省
num1 = 10+2j
num2 = 2 - 1j
num3 = 20j
print(type(num1), type(num2))

python支持复数运算
print(num1 + num2)
print(num1 * num2)
"""
10    2
2j    -1j
-10j + 20 + 4j + 2 = 22-6j

1.5 数据类型转换

python中所有数据类型的转换方式: 类型名(数据)

1）整型: int(数据) - 将制定的数据转换成10进制的整数
所有的数字类型对应的数据都可以转换成整型(复数不行)，部分字符串也可以转换成整型
对于字符串来说，去掉引号以后本身是合法的制定进制的整数对应的字符串才能转换成对应的整型

print(int(12.5), int(-12.9))    # 12, -12
print(int(True), int(False))    # 1, 0
print(int('123'))    # 123
print(int('+123'), int('-123'))    # 123 -123

# 错误例子：
# print(int('123.25'))    # 报错
# print(int('abc'))    # 报错


int(数据，进制数)
print(int('0b1101', 2))
print(int('1101', 2))     # 13

# 错误例子：
print(int('1201', 2))   # 报错

2）浮点型：float(数据)
整型和布尔都可以转换成浮点型，部分字符串也可以转换成浮点型(去掉引号后本身就是一个合法的浮点型或者整型数据)。

print(float(10))     # 10.0
print(float(True))   # 1.0
print(float('100'))  # 100.0
print(float('12.5'))  # 12.5

# 错误例子：
# print(float('12.5a'))  # 报错


print(float('3e4'))   # 30000.0

3）布尔：bool(数据)
所有类型的所有的数据都可以转换成布尔。
所有零值或者空值会转换成False,其他都是True

2. 列表基础

2.1 容器型数据类型：

是可以同时保存多个数据的数据。

常见的容器型数据类型有：列表、元组、字典、集合、字符串、迭代器、生成器。
容器中的每个独立的数据叫元素。

2.2 列表

1）什么是列表列表是容器型数据类型，将[]作为容器的标志，里面的多个数据(元素)用逗号隔开。
比如: [120, 30, 40]
2）列表是可变的(列表中元素的个数和值可变);列表是有序的。

3）列表中的元素: 可是任何类型的数据；不同元素的类型可以不一样。

# 实例：把成绩存入列表scores,并输出结果。
scores = [90, 89, 67, 90, 56, 88]
print(scores)

# 实例：随意创建一个列表，输出结果。
list1 = [90, 12.89, True, 'abc', [1, 2, 3]]
print(list1)

2.3获取列表元素

1)获取单个元素

"""
语法：
列表[下标]

说明：
列表  -  任何结果是列表的表达式: 独立的列表数据、保存列表的变量、返回值是列表的函数调用表达式、结果是列表的运算表达式
[]   -  固定写法
下标  -  想要获取的元素对应的下标

补充：什么是下标
下标又叫索引，是用来表示有序序列中元素的位置(顺序)。
列表中的每个元素都有固定的下标用来表示这个元素在列表中的位置，下标值的范围是从0开始依次增加，其中0表示第一个元素...
列表中的每个元素有两种下标值，一种是正的下标值(从0开始),另一种是负的下标值(从-1开始，依次减少，-1表示是最后一个元素)

注意: 下标不能越界,有多少元素限制标多少。
"""
# 例如：
names = ['张飞', '刘备', '关羽']
print(names[1], names[-2])    # 刘备 刘备
print([1, 2, 3, 4][1])

# 错误案例：
print(names[10])    # IndexError: list index out of range

2)获取部分元素 - 切片

"""
语法：
列表[开始下标:结束下标:步长]  - 从开始下标开始，每次下标值增加步长，取到结束下标前为止

说明：
列表  -  任何结果是列表的表达式: 独立的列表数据、保存列表的变量、返回值是列表的函数调用表达式、结果是列表的运算表达式
[]   -  固定写法
开始下标、结束下标  - 下标值,整数
步长  -  整数


如果步长是正，表示获取元素的时候是从前往后取， 保证开始下标对应的元素要在结束下标对应的元素的前面，否则切片的结果是[]；
如果步长是负，表示获取元素的时候是从后往前取, 保证开始下标对应的元素要在结束下标对应的元素的后面，否则切片的结果是[]。


注意: 切片的时候下标可以越界
"""
# 举例：
nums = [1, 2, 3, 4, 5, 6, 7, 8]
print(nums[1:4:1])    # range(1, 4, 1) -> 1, 2, 3

names = ['鲁班7号', '亚索', '妖姬', '盲僧', '狗头']
print(names[1:3:1])      # ['亚索', '妖姬']
print(names[-4:3:1])     # ['亚索', '妖姬']
print(names[1:-1:2])     # ['亚索', '盲僧']
print(names[4:1:1])    # []
print(names[-1:1:1])   # []
print(names[-1:1:-1])  # ['狗头', '盲僧', '妖姬']
print(names[-1:0:-2])    # ['狗头', '妖姬']
print(names[2:5:1])    # ['妖姬', '盲僧', '狗头']

3)切片语法的省略写法

"""
a. 省略步长
列表[开始下标:结束下标]  ---> 列表[开始下标:结束下标:1]
"""
names = ['鲁班7号', '亚索', '妖姬', '盲僧', '狗头']
print(names[1:4])      # ['亚索', '妖姬', '盲僧']
print(names[-2:4])     # ['盲僧']
print(names[-1:4])     # []


"""
b. 省略开始下标
列表[:结束下标:步长] / 列表[:结束下标]

步长为正， 表示从第一个元素开始往后取
步长为负，表示从最后一个元素开始往前取
"""
movies = ['肖生克的救赎', '乡村老尸', '霸王别姬', '绿里奇迹', '辛德勒的名单', '盗梦空间']
print(movies[:-1])    # ['肖生克的救赎', '乡村老尸', '霸王别姬', '绿里奇迹', '辛德勒的名单']
print(movies[:2:-1])   # ['盗梦空间', '辛德勒的名单', '绿里奇迹']
print(movies[:0:-2])  # ['盗梦空间', '绿里奇迹', '乡村老尸']


"""
c. 省略结束下标
列表[开始下标::步长] / 列表[开始下标:]

步长为正，从前往后取到最后一个元素为止
步长为负，从后往前取到第一个元素为止
"""
print(movies[-3:])    # ['绿里奇迹', '辛德勒的名单', '盗梦空间']
print(movies[-1::2])  # ['盗梦空间']


"""
d. 同时省略开始下标和结束下标
列表[::步长] / 列表[:]

步长为正，从第一个元素取到最后一个元素
步长为负，从最后一个元素取到第一个元素
"""
movies = ['肖生克的救赎', '乡村老尸', '霸王别姬', '绿里奇迹', '辛德勒的名单', '盗梦空间']
print(movies[::-1])    # ['盗梦空间', '辛德勒的名单', '绿里奇迹', '霸王别姬', '乡村老尸', '肖生克的救赎']
print(movies[:])     # ['肖生克的救赎', '乡村老尸', '霸王别姬', '绿里奇迹', '辛德勒的名单', '盗梦空间']
print(movies[::2])   # ['肖生克的救赎', '霸王别姬', '辛德勒的名单']

4）遍历列表 - 将列表中的元素一个一个的取出来

"""
方法一：直接法
for 变量 in 列表:
    循环体
    
方法二：通过下标间接获取
for 下标 in 下标对应的数字序列:
    列表[下标]
    循环体
"""
movies = ['肖生克的救赎', '乡村老尸', '霸王别姬', '绿里奇迹', '辛德勒的名单', '盗梦空间']
for m in movies:
    print(m)

print('===================================')
len(列表) - 返回列表中元素的个数
for index in range(len(movies)):
    print(movies[index])

练习：用一个列表保存一个班所有学生的分数，统计不及格学生的人数,并计算班级学生的平均分。
scores = [89, 45, 60, 23, 68, 9, 76]
count = 0
for score in scores:
    if score < 60:
        count += 1
print('不及格学生人数:', count)


sum1 = 0
for score in scores:
    sum1 += score
print('平均分：', sum1 / len(scores))

3.列表元素

3.1 增 - 添加元素

1)append - 追加

列表.append(元素)   -  在指定列表的最后添加指定的元素

list1 = [10, 20, 30]
print(list1)
list1.append(100)
print(list1)

2)insert - 插入

列表.insert(下标, 元素)   -  在指定列表指定下标对应的元素前插入指定的元素

list1 = [10, 20, 30]
list1.insert(1, 100)
print(list1)

3.2 删 - 删除元素

1） del语句

del 列表[下标]   - 删除列表中指定下标对应的元素(下标不能越界)

teleplays = ['甄嬛传', '大明王朝', '琅琊榜', '庆余年', '还珠格格', '请回答1988']
del teleplays[2]
print(teleplays)

del teleplays[-4]
print(teleplays)

2） remove

列表.remove(元素)  - 删除列表中指定的元素（如果指定的元素不存在，程序会报错;如果指定的元素存在多个，只删最前面的那一个）

# teleplays.remove('西游记')   # ValueError: list.remove(x): x not in list(报错)

teleplays = ['甄嬛传', '大明王朝', '琅琊榜', '庆余年', '还珠格格', '请回答1988', '甄嬛传']
teleplays.remove('甄嬛传')
print(teleplays)

3） pop

列表.pop()  -  取出列表中的最后一个元素，并且返回被取出的元素
列表.pop(下标)  -  取出列表中指定下标对应的元素，并且返回被取出的元素

teleplays = ['甄嬛传', '大明王朝', '琅琊榜', '庆余年', '还珠格格', '请回答1988', '甄嬛传']
t = teleplays.pop(1)
print(teleplays)
print(t)

t = teleplays.pop()
print(teleplays, t)

3.3 改 - 修改元素的值

a. 列表[下标] = 新元素    -  将列表中指定下标对应的元素修改成新的元素 (下标不能越界)  
anime_list = ['火影忍者', '海贼王', '死神', '天线宝宝', '死亡笔记']
anime_list[-2] = '海绵宝宝'
print(anime_list)


*b. 列表1[开始下标:结束下标] = 列表2    -  将列表1中开始下标到结束下标选中的所有元素替换成列表2中所有的元素
nums = [10, 20, 30, 40, 50]
nums[1:3] = [100, 200, 300]    # [10, 100, 200, 300, 40, 50]
print(nums)

3.4in 和 not in

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

print(10 in nums)     # True
print(20 not in nums)     # True