python学习日记4 python基本语法（数学功能及列表）

一、常用数学功能简单整理

1.内置功能

abs(x):返回数字的绝对值
(x>y)-(x<y):比较大小，如：x=3,y=5
max(x1,x2,…):返回给定参数的最大值
min(x1,x2,…):返回给定参数的最小值
pow(x,y):求x的y次方的值
round(x,n):返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数

2.math模块

ceil(x):返回x的上入整数，不能直接访问，需要通过math访问，即math.ceil(18.1)	
floor(x):返回x的下入整数，同ceil的用法
modf(x):返回x的整数部分和小数部分，两部分的数值符号与x相同，整数部分以浮点型表示，同ceil的用法
sqrt(x):返回数字x的平方根，数字可以为负数，返回类型为实数【浮点型】，同ceil的用法

3.随机数功能

import  random
random.choice(容器)          #       *******
random.randint(start,end)    # 注意：step默认为1，无法自定义   随机范围为闭区间   ****
random.randrange(start,end,step)# 类似range(start,end,step),start和step都可以省略
random.sample(容器,n)        # ******
# 作用：从指定的容器中随机选择n个数据，得到的结果是一个列表
# 注意：容器中的数据是被一次性取出来的，所以同一个数据只能被提取一次
random.random() # 获取0~1之间的任意一个随机浮点数,[0,1)前闭后开区间      *****
random.uniform(a,b)  # 获取a~b之间的任意一个随机浮点数，底层还是通过random()进行计算的    ******

二、列表

​ 作用：列表相当于是一个容器，可以同时存储多种类型的数据

​ 本质：列表是一个有序的，可以存储重复元素的集合

​ 说明：有序指的就是有顺序【数据的存放的顺序和底层存储的顺序是相同的】

1.定义列表

​ 定义一个列表相当于定义一个列表类型的变量
变量名 = 值
语法：列表名 = [数据1,数据2,数据3…]

说明：

​ a.列表名其实就是一个变量名【标识符】，注意：尽量不要直接使用list【系统有一个功能list(x)】

​ b.[]是列表特有的表示方式

​ c.数据1,数据2,数据3被称为元素

​ d.列表中的元素会被自动编号，从0开始，该编号被称为索引，下标或者角标

​ e.索引的取值范围：0 ~ (元素个数 - 1)

2.列表元素访问

# 注意1：因为列表是有序的，所以列表可以通过索引访问元素

# 1.获取元素
# 语法：列表[索引]
numlist = [45,56,65,100,2,15]
print(len(numlist))  # 获取列表中元素的个数

"""
正数索引：0      1    2     3   4   5
负数索引：-6    -5   -4    -3  -2   -1
元素：    45    56   65   100   2  15
索引的取值范围：
    a.正数索引：0~len(xx) - 1
    b.负数索引：-1 ~ -len(xx)
"""
# 注意：访问列表中元素的时候，一定要注意索引的取值范围，如果越界，则报错IndexError
# print(numlist[10])  # IndexError: list index out of range

# 2.修改元素
# 语法：列表[索引] = 值
numlist[-1] = 33

3.列表基本操作

# 1.+:组合
l1 = [1,2,3]
l2 = [6,7,8]
print(l1 + l2)   # [1, 2, 3, 6, 7, 8]

# 2.*
print(l1 * 3)   # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 注意：+和*应用在列表中，都是生成了一个新的列表，并没有修改原列表

# 3.in和not in:判断指定的元素是否在指定的列表中，一般和if语句结合使用
numlist = [11,22,33]
print(11 in numlist)  # True
print(11 not in numlist)  # False

4.遍历列表

# 方式一
i = 0
while i < len(list1):
    print(list1[i])
    i += 1

# 方式二:直接获取元素        ******
for n in list1:
    print(n)

# 方式三：获取索引             ******
for i in range(len(list1)):
    print(i,list1[i])

# 方式四：同时获取索引和元素
# r = enumerate(list1)    # enumerate(x)将x容器转换为一个新的容器【枚举】，新的容器中的元素包括索引和元素
# print(list(r))   # [(0, 34), (1, 5), (2, 6), (3, 67)]
for index,ele in enumerate(list1):
    print(index,ele)

5.列表系统功能

​ 列表是可变的，所以涉及到列表元素的增，删或改的操作，基本都是在原列表内部进行的，并没有生成一个新的列表

5.1 增

# 1.append(obj):在列表末尾追加新的元素,注意：obj可以是任意的类型          ******
list1 = [11,22,33]
list1.append(44)
print(list1)  #  [11,22,33,44]

# 2.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list2 = [11,22,33]
list2.extend('abc')  
print(list2)   # [11, 22, 33, 'a', 'b', 'c']
"""
注意
    a.列表.append()可以添加任意类型的元素
      列表.extend()只能添加可迭代对象的元素，可迭代对象：本质是一个容器，可以通过for循环遍历其中的元
      素，如：列表，字符串，元组，字典，集合.....
    b.列表.append()：如果添加的是容器，则整个容器会被添加到原列表中
      列表.extend()：只会将指定容器中的元素添加到原列表中
"""

# 3.insert(index,obj)：将元素插入到列表的指定位置
# 注意：在指定列表的指定索引处插入一个元素，原来的元素向后顺延
# 注意：insert(index,obj),index可以越界，如果越界，默认将指定元素插入到末尾
list3 = [11,22,33]
list3.insert(1,44)
print(list3)   # [11, 44, 22, 33]

5.2 删

# 1.remove(元素):移除列表中某个值的第一个匹配项          *******
list1 = [23,5,34,5,5,10]
list1.remove(5)
print(list1)

# 2.pop(索引):移除列表中指定索引处的元素（默认最后一个元素），并且返回该元素的值     *****
list2 = [23,5,34,5,5,10]
# a.如果未指定索引，默认删除最后一个元素
# b.如果指定索引，则删除指定索引处的元素
# c.区别于remove，pop只是将元素从列表中移除，但是在内存中存在,所以可以用变量将值接出来
r2 = list2.pop(1)
print(r2)

# 3.clear()：清空列表
list3 = [23,5,34,5,5,10]
list3.clear()
print(list3)   # []

# 4.del  xxx
# a.del 列表[索引]  这个是删除元素
list3 = [23,5,34,5,5,10]
del list3[1]    # 等价于list3.pop(1)
print(list3)    # [23,34,5,5,10]

# b.del 列表   直接把列表list3这个对象删除
del list3
# print(list3)   # NameError: name 'list3' is not defined

5.3 改

# 1.reverse():反转/翻转                 *******
list1 = [34,45,5,67,100,50]
list1.reverse()
print(list1)

# 2.sort():排序  对原列表进行排序，sorted（）是排序后传给新列表对原列表没有影响       ********
# a.升序
list1 = [34,45,5,67,100,50]
list1.sort()
print(list1)

# b.降序，sort(reverse=True)
list1 = [34,45,5,67,100,50]
list1.sort(reverse=True)
print(list1)

# 注意：关于sort(),目前升序和降序的用法只适用于数字或者字符串类型的列表进行排序，如果有其他的排序规则，需要借助于函数

5.2 查

numlist = [34,6,56,6,6,7,6,134,50,30]

# 1.len():获取列表的长度                       ******
print(len(numlist))

# 2.max()/min():获取列表中元素的最值
print(max(numlist))
print(min(numlist))

# 3.index(ele,[start,end]):获取一个元素在列表中第一次出现的索引           *****
r1 = numlist.index(6)
print(r1)

# a.全局查找
r1 = numlist.index(6)
print(r1)

# b.局部查找,仍然符合包头不包尾的规则，返回的仍然是原列表中的索引
r1 = numlist.index(6,1,5)
print(r1)    # 1

# 4.count():统计一个元素在列表中出现的次数             ******
r = numlist.count(6)
print(r)

6.列表推导式

​ 列表推导式，就是指的轻量级循环创建列表

​ 列表推导式/列表生成式:是Python特有的语法，通过循环和if语句专门用来创建列表
特点：根据一个已知的Iterable,使用一行代码实现简单的逻辑，生成一个新的列表

​ 语法：[新列表中的元素规律 for循环 if语句]

​ 工作原理：执行for循环，获取已知Iterable的元素，结合if判断，最终得到新的列表中元素的规律

# 1.已知一个列表list1 = [3,5,23,10],生成一个新的列表，新列表中的元素是list1中元素的2倍
list1 = [3,5,23,10]
# 方式一
list11 = []
for ele in list1:
    list11.append(ele * 2)
print(list11)

# 方式二  【列表推导式】
list12 = [ele * 2 for ele in list1]
print(list12)

7.列表拷贝

​ 两个变量的地址相同，则这两个变量的值一定相同。
两个变量的值相同，则这两个变量的地址不一定相同。

7.1 = 引用赋值

# a.一维列表
list1 = [11,22,33]
list2 = list1
print(list1 is list2)  # True
list1[1] = 100
print(list1 is list2)  # True
print(list1)    # [11, 100, 33]
print(list2)    # [11, 100, 33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = list1
print(list1 is list2)  # True
list1[0][1] = 100
print(list1 is list2)  # True
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

"""
结论：
    无论是一维列表还是多维列表，如果使用引用赋值的方式操作，
    只要通过一个变量修改了列表中的元素，则另一个变量访问的列表也会随着修改
"""

7.2 浅拷贝

浅拷贝:只拷贝列表的最外层

# 1.列表.copy():浅拷贝
# a.一维列表
list1 = [11,22,33]
list2 = list1.copy()
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = list1.copy()
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

import  copy
# 2.copy.copy()：浅拷贝
# a.一维列表
list1 = [11,22,33]
list2 = copy.copy(list1)
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = copy.copy(list1)
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

"""
结论：列表.copy() 和 copy.copy(列表) 和 切片
    一维列表：如果一个变量修改列表中的元素，对另一个列表没有任何影响
    二维列表：如果一个变量修改内层列表中的元素，则另一个列表中的元素会随着发生修改    
"""

7.3 深拷贝

​ 深拷贝：不管列表嵌套了几层，都会拷贝

copy.deepcopy()：深拷贝
# a.一维列表
list1 = [11,22,33]
list2 = copy.deepcopy(list1)
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = copy.deepcopy(list1)
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,22,33],[44,55]]

"""
结论：copy.deepcopy()
    无论是一维列表还是多维列表，如果使用copy.deepcopy()的方式操作，
    通过一个变量修改了列表中的元素，另一个变量访问的列表没有影响
"""

注意：不管是浅拷贝还是深拷贝，都会生成一个新的列表，所以列表的地址都会发生改变

8.列表切片

​ 切片：根据指定的区间，指定的步长，在列表，元组或字符串等有序集合中进行截取，形成一个新的列表，元组或字符串

语法：
列表名[start：e nd：step]
start:开始索引，可以省略，默认为0，不省略的情况下包含在内
end:结束索引，可以省略，默认为索引的结束【len - 1 或 -len】,不省略的情况下不包含在内
step：表示步长，可以省略，默认为1

注意：
1.只要符合切片的语法，代码永远不会报错，只是结果列表是否为空
2.能获取到元素的前提下，只要step为负数，则表示逆序获取

注意：列表切片之后会得到一个新的列表，对原列表没有任何影响,相当于是列表的拷贝

"""
  0   1   2   3   4   5   6   7     8
 -9   -8  -7  -6  -5  -4  -3  -2   -1
 11   22  33  44  55  66  77  88   99
"""
numlist = [11,22,33,44,55,66,77,88,99]

# 一、基本使用
# 1.省略start或end或step
# 注意1：start包含在内的，end如果定义出来不包含在内
print(numlist[1:])   # [1::1]   [22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[1:8])  # [22, 33, 44, 55, 66, 77, 88]

print(numlist[:6])   # [11, 22, 33, 44, 55, 66]

# 注意2：如果end超出索引的范围，默认取到结尾     *******【面试题】
print(numlist[1:100])   # [22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[1:9])     # [22, 33, 44, 55, 66, 77, 88, 99]

# 注意3：numlist[:]表示将原列表拷贝了一份,经常用于一维列表的备份   *******
print(numlist[:])
print(numlist[::])
print(numlist[::1])
print(numlist[::2])   # [11, 33, 55, 77, 99]

# 2.start和end同正负
"""
规律1：如果start和end同正负
    a.计算start+step
    b.判断上述结果是否在start和end区间内
    c.如果在区间内，则按照规律获取元素，如果不在区间内，则结果直接为[]
"""
# a.start和end都是正数索引
print(numlist[1:5:1])   # [22...55]
print(numlist[1:5:-1])  # []

print(numlist[5:1:1])   # []
print(numlist[5:1:-1])  # [66...33]

# b.start和end都是负数索引
print(numlist[-1:-5:1])   # []
print(numlist[-1:-5:-1])  # [99...66]

print(numlist[-5:-1:1])   # [55...88]
print(numlist[-5:-1:-1])  # []

# 3.start和end一个为正数，一个为负数
"""
规律2：start和end一个为正数，一个为负数
    a.观察start的正负，索引的使用和start的正负保持一致
    b.如果start为正，则使用正数索引；如果start为负，则使用负数索引
    c.将end的索引转换为和start同符号的索引
    d.继续使用规律1判断
"""
print(numlist[1:-5:1])      # [1:4:1]  -----》[22...44]
print(numlist[1:-5:-1])     # [1:4:-1]---->[]

print(numlist[-1:5:1])      # [-1:-4:1]----->[]
print(numlist[-1:5:-1])     # [-1:-4:-1]---->[99...77]

print(numlist[-5:1:1])      # [-5:-8:1]----->[]
print(numlist[-5:1:-1])     # [-5:-8:-1]---->[55...33]

# 二、特殊情况
# 1.
"""
规律3：如果start和end都被省略
    a.如果step为正数，则从左往右获取【顺序获取】
    b.如果step为负数，则从右往左获取【逆序获取】
"""
print(numlist[::1])
print(numlist[::2])

print(numlist[::-1])                    # ******* 倒序/反转
print(numlist[::-2])

# 2.
# print(numlist[100])    # IndexError  索引值超过列表长度
print(numlist[1:100])   #[22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[100:])    # []    面试题     *********

# 3.
print(numlist[0:-1:1])  # [0:8:1] ---->[11...88]
print(numlist[0:-1:-1]) # [0:8:-1]--->[]

print(numlist[-1:0:1])  # [-1:-9:1]---->[]
print(numlist[-1:0:-1]) # [-1:-9:-1] ----->[99...22]

# 4.
"""
规律4：列表[start::step]
    a.如果step为正数，则从左往右获取【顺序获取】
    b.如果step为负数，则从右往左获取【逆序获取】
"""
print(numlist[5::1])
print(numlist[5::-1])
print(numlist[-5::1])
print(numlist[-5::-1])