初识python

注意事项

Python程序的文件是以.py为后缀
python程序的文件名最好不要有中文和特殊字符
python代码中不要使用中文的标点符号，应该使用英文的
python代码行尾不需要加分号（与其他语言的区别）
打印引号内的内容
井号(#)的的作用是注释一行内容，注释后程序在执行时不会被执行
多行注释:
“”"
原理：根据对象的引用计数器，对象创建会给对象一个引用计数器，如果该值为0，那么对象会被释放。创建了一个字符串对象，但是没有任何的引用，所以它的引用计数器为0
“”"
注意：
良好的代码中应该有50%左右的注释

输入与输出

# 输出
# 会在屏幕打印一行内容
print("sunck is a good man")
# 可以打印多个字符串，多个字符串用逗号分隔，逗号会表现为一个空格
# 还可以打印数字
# 帅的人都会在逗号后面加上一个空格，为了美化代码
print("sunck is a good man", "sunck is a nice man", 18)
print("-----------------------")
# 不写end，默认职位\n字符，叫做换行符，一般情况下无需程序员指定
print("sunck", end="#")
print("good")
# 输入
# input括号中的内容为提示信息，展示在屏幕上
# 程序在遇到input时会阻塞，等待用户输入内容，输入内容后在继续运行
# 输入的内容被等号左侧的“东西”保存
word = input("请输入内容:")
print("***************", word)

数据类型

计算机顾名思义就是存储数据计算数据的，因此，计算机理论上应该能处理各种各样的数据（包含数字、文本、图像、视频、音频、网页等），不同的数据，需要定义不同的数据类型

Number(数字类型)
    整数
    浮点数
    复数
String(字符串类型)
Boolean(布尔类型)
None(空类型)
list(列表类型)
tuple(元组类型)
dict(字典类型)
set(集合类型)

标识符

概念： 是一串字符串，但是字符串可不一定是标识符
标识符规则：

• 1、只能由字母、数字、下划线组成($可以在标识符中使用)
• 2、开头不能是数字
• 3、不能是python的关键字
• 4、区分大小写
• 5、见名之意
  作用： 给变量、函数、类等命名的
  注意：在python3中，非ASCII字符的标识符也是允许的，但是不建议使用

关键字： 是语言规定了特殊含义的字符串
保留字： 是语言保留起来的字符串，当前没有特殊含义，以后可能会有特殊含义
打印python中的所有关键字

import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break',
 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

变量与常量

变量

• 概述
  1、程序可操作的存储区的名称
  2、程序运行期间可以改变的数据
  3、每个变量都有特定的类型
• 作用
  将不同类型的数据存储到内存
• 变量的定义
  格式：变量名 = 初始值(为了确定变量的类型)
• 变量的赋值(数据的存储)
  格式：变量名 = 值
• 变量的使用(处理数据)
  注意：变量在使用前必须要先定义，否则会出错

num = 0  #定义名为num的变量，并赋初始值为0
num = 5  #将变量的值赋值为5
print("num =", num) # 使用变量

常量

程序运行期间不能改变的数据

Number类型

分类：

• 整数
• 浮点数
• 复数

整数

python中的可以处理任意大小的整数

• 定义

# type()可以查看变量的类型
print(type(num1)) #<class 'int'>
#  id()可以查看变量的地址 #1453354288
#  hex()可以将十进制转为十六进制，十六进制数字展示时前面带有0x前缀 #0x56a06d30
# 变量的地址为所占内存第一个字节的地址(首地址)
print(hex(id(num1)))

• 连续定义多个变量

num2 = num3 = num4 = 9
print(hex(id(num2)), hex(id(num3)), hex(id(num4)))
#0x56a06d10 0x56a06d10 0x56a06d10    地址一样

• 交互对称赋值定义变量

num5, num6 = 8, 9
print(hex(id(num5)), hex(id(num6)))

总结

• 1、相同值的变量的地址是相同的
• 2、修改变的值其实是让变量表示另一片内存空间

浮点数

由整数部分与小数部分组成，就是我们所熟知的小数

num9 = 2.4
num10 = 2.7
print(type(num9))
# python浮点运算会有四舍五入的误差
print(num9 + num10) # 5.1   5.1000000001

数字类型转换

num11 = 10
num12 = float(num11)
print(num12, type(num12))   #10.0 <class 'float'>
num13 = 1.634
# 提取了整数部分，小数部分不要了
num14 = int(num13)
print(num14, type(num14))   #1 <class 'int'>

数学函数

• abs() 得到数字的绝对值

num15 = -10
num16 = abs(num15)
print("num16 =", num16)
# %d是占位符，说明这个位置需要有一个整数来替换
print("num16 = %d-------%d"%(num16, 12))

• max() 得到所有数字的最大值

num17 = max(1,4,7,2,4,3,8,8,5)
# 如果仅仅只有一个占位符，那么小括号可以省略，但是最好不要省略
print("num17 = %d"%num17)

• min() 得到所有数字的最小值

print("num18 = %d"%num18)

• pow(x, y) 得到x的y次方
• round(x[, n]) 对x值进行四舍五入，如果给出了n则表示保留小数点后n位

print(pow(3, 3)) 
print(round(1.1))
print(round(1.5))
print(round(1.123456, 4))
#27   1     2       1.1235

引入math模块

import math
# 6、向上取整  ceil()
print(math.ceil(1.1))
# 7、向下取整
print(math.floor(1.9))
# 8、分离整数部分与小数部分
print(math.modf(2.4))
# 9、开平方
print(math.sqrt(25))
#输出结果为： 
2
1
(0.3999999999999999, 2.0)
5.0
#10、 math.frexp(75) 把一个浮点数分解为尾数和指数
frexp(16.400000,&n)=0.512500,n=5
16.4 = 0.5125 * 2^5 = 0.5125 * 32
#11、把y的正负号加到x前面，可以使用0
>>> math.copysign(2,-3)
-2.0
#12 e表示一个常量
>>> math.e
2.718281828459045
# 13.expm1()返回math.e的x(其值为2.71828)次方的值减１
>>> math.expm1(2)
6.38905609893065

# 14 fabs()返回x的绝对值
>>> math.fabs(-0.03)
0.03

# 15 factorial()取x的阶乘的值
>>> math.factorial(3)
6
# 16 对迭代器里的每个元素进行求和操作
>>> math.fsum((1,2,3,4))
10.0

#17 返回x和y的最大公约数
>>> math.gcd(8,6)
2

#18 得到(x2+y2),平方的值
>>> math.hypot(3,4)
5.0

#19 isfinite()如果x不是无穷大的数字,则返回True,否则返回False
>>> math.isfinite(0.1)
True

#20 isinf()如果x是正无穷大或负无穷大，则返回True,否则返回False
>>> math.isinf(234)
False
#21 isnan()如果x不是数字True,否则返回False
>>> math.isnan(23)
False

#22 ldexp()返回x*(2**i)的值
>>> math.ldexp(5,5)
160.0

#23 log(x,a) 如果不指定a，则默认以e为基数，a参数给定时，将 x 以a为底的对数返回。
>>> math.log(math.e)
1.0
>>> math.log(32,2)
5.0
>>>

#24 log10()返回x的以10为底的对数
>>> print(math.log10(10))
>1.0
#25 log2()返回x的基2对数
>>> math.log2(32)
5.0
#26 exp()返回math.e(其值为2.71828)的x次方
>>> math.exp(2)
7.389056098930 65
# 27、三角函数
求x的余弦，x必须是弧度
>>> math.cos(math.pi/4)
>0.7071067811865476
把x从弧度转换成角度
>>> math.degrees(math.pi/4)
45.0
radians()把角度x转换成弧度
>>> math.radians(45)
0.7853981633974483

sin()求x(x为弧度)的正弦值
>>> math.sin(math.pi/4)
0.7071067811865476

sqrt()求x的平方根
>>> math.sqrt(100)
10.0

tan()返回x(x为弧度)的正切值
>>> math.tan(math.pi/4)
0.9999999999999999

导入random模块

import random
# 1、在范围内选取一个数字
num19 = random.choice(range(5))# 0 1 2 3 4
print("num19 = %d"%num19)
num20 = random.choice([1,3,5,7,9])#
print("num20 = %d"%num20)
num21 = random.choice("sunck")#
print("num21 = %s"%num21)


# 2、randrange([start, ]stop[, stap])
'''
randrange(stop)
randrange(start, stop)
randrange(start, stop, step)
作用：在start(没写start默认为0)与stop（不包含）这个范围内，按照指定step基数递增集合中获取一个数字，step默认为1
'''
print(random.randrange(1, 10, 2))# 1 3 5 7 9
# 3、random()  在[0, 1)区间选取随机数
print(random.random())
# 4、uniform(x, y)  在[x, y]之间随机生成一个浮点数
print(random.uniform(1, 5))
num22 = 1.636
print("num22 = %f"%(num22))  #浮点数占位符
print("num22 = %.2f"%(num22))  # %.2f  格式化输出两位小数

num23 = 12345
print("num23 = %d"%(num23))
print("num23 = %3d"%(num23))
print("num23 = %6d"%(num23))
print("num23 = %.6d"%(num23))

运算符和表达式

• 表达式：
  由变量、常量、运算符组成的式子
• 阅读表达式：
  • 1、阅读表达式的功能
  • 2、阅读表达式的值

算术运算符与算术运算表达式

算术运算符

 +      -     *      /      %            **       //
 加    减     乘     除     取模(取余)    求幂     求整
 ```
- 算术运算符表达式
 - 功能：进行相应的符号运算，不会改变变量的值
-  值：相关的运算结果

赋值运算符与赋值运算表达式

• 赋值运算符
  =
• 赋值运算表达式
  • 格式：变量 = 表达式
  • 功能：计算等号右侧“表达式”的值，将其赋值给等号左侧的“变量”
  • 值：赋值结束后变量的值
• 复合运算符

  +=      a += b 相当于 a = a + b
  -=      a -= b 相当于 a = a - b
  *=      a *= b 相当于 a = a * b
  /=
  %=
  **/
  //=
  

• 位运算符

作用：
   把数字看作二进制来进行计算
符号：
&
   按位与运算符：参与运算的两个数字，如果两个相应的位都是1，则该位为1，否则为0
|
   按位或运算符：参与运算的两个数字，只要相应的位有一个为1，则该位为1，否则为0
^
   按位异或运算符：参与运算的两个数字，相应的位相异时，则该位为1，否则为0
~
   按位取反运算符：参与运算的数字，每个二进制的位取反
<<
   左移动运算符：运算数的各位二进制位全部向左若干位，由符号右侧的数字指定，高位丢弃，低位补0
>>
   右移动运算符：运算数的各位二进制位全部向右若干位，由符号右侧的数字指定，低位丢弃，高位补0
'''

'''
   101
   111
-------------
   101
'''
print(5 & 7)
'''
   101
   111
-------------
   111
'''
print(5 | 7)
'''
   101
   111
-------------
   010
'''
print(5 ^ 7)
'''
   0000 0101
------------------
   1111 1010
   
   1000 0101
   1000 0110
'''
print(~5)
'''
   0000 0010
------------------
   0000 1000
'''
print(2 << 2)
'''
   0000 1101
------------------
   0000 0011
'''
print(13 >> 2)

关系运算符与关系运算表达式

• 关系运算符

     <        >=       <=          ==        !=
  

    大于     小于     大于等于  小于等于    等于       不等于
  

• 关系运算表达式
  格式： 表达式1 关系运算符 表达式2
  功能：计算表达式1与表达式2的值
  值：如果关系成立，则关系运算表达式的值为真，否则为假

逻辑运算符

• 逻辑与

  • 符号 and
  • 逻辑与运算表达式
    • 格式：
      • 表达式1 and 表达式2
      • 表达式1 and 表达式2 and 表达式3 and …… and 表达式n
    • 功能：从左至右依次计算表达式的值，直到某个表达式的值为假才停止
    • 值：
      • 如果表达式1的值为真，表达式2的值为真，则整个逻辑与运算表达式的值为真
      • 如果表达式1的值为真，表达式2的值为假，则整个逻辑与运算表达式的值为真
      • 如果表达式1的值为假，表达式2的值为真，则整个逻辑与运算表达式的值为真
      • 如果表达式1的值为假，表达式2的值为假，则整个逻辑与运算表达式的值为假
      • 一句话：有一个为假就为假

• 逻辑或

  • 符号：or
    逻辑或运算表达式
  • 格式：
    • 表达式1 or 表达式2
    • 表达式1 or 表达式2 or 表达式3 or …… or 表达式n
  • 功能：从左至右依次计算表达式的值，直到某个表达式的值为真才停止
  • 值：
    • 如果表达式1的值为真，表达式2的值为真，则整个逻辑或运算表达式的值为真
    • 如果表达式1的值为真，表达式2的值为假，则整个逻辑或运算表达式的值为假
    • 如果表达式1的值为假，表达式2的值为真，则整个逻辑或运算表达式的值为假
    • 如果表达式1的值为假，表达式2的值为假，则整个逻辑或运算表达式的值为假
    • 一句话：有一个为真就为真

• 逻辑非

  • 符号 not
  • 逻辑非运算表达式
    • 格式：not 表达式
    • 功能：计算表达式的值
    • 值：
      • 如果表达式的值为真，则逻辑非运算表达式的值为假
      • 如果表达式的值为假，则逻辑非运算表达式的值为真
      • 一句话：颠倒黑白

成员运算符

• 符号
  • in 如果在指定的集合中返回真，否则返回假
  • not in 如果不在指定的集合中返回真，否则返回假
• 格式
  • x in seq
  • x not in seq

身份运算符

• 符号
  • is 判断两个标识符是否引用同一个对象，是的话返回真，否则返回假
  • not is 判断两个标识符是否引用同一个对象，不是的话返回真，否则返回假
• 格式
  obj1 is obj2
  obj1 not is obj2

运算符优先级（由高到低）

•   **
  

• ~ + -                   按位取反、一元运算符(正负号)
  

•      * / % //
  

•   + -                   二元运算符  
  

•  << >>
  

•  &
  

• | ^
  

•    < > <= >=
  

•    == != <> 
  

•   = += -= *= /= %= //= **=
  

• is   not is
  

• in   not in
  

•  and or not
  

String

定义

字符串是以单引号’或者双引号"括起来的任意文本
注意：
1、引号本身是一种表现形式，不属于字符串内容
2、如果字符串本身带单引号，外出用双引号包裹
“he’s a good man”

创建

str1 = “sunck is a good man”
str2 = ‘sunck is a nice man’

字符串运算

str3 = “sunck is a good man”
str4 = ‘sunck is a nice man’

字符串加法（字符串拼接）

str5 = str3 + str4
print(“str5 = %s”%(str5))
输出：str5 = sunck is a good mansunck is a nice man

字符串乘法(重复字符串)

str6 = str3 * 3
print("str6 = %s"%(str6))
输出：str6 = sunck is a good mansunck is a good mansunck is a good man

内容获取

• 根据下标(索引)获取字符串中的内容，下标(索引)从0开始
• 字符串[下标] #str8 = str7[2]
• 截取字符串中的一部分 #print(str7[2:13])#包含前面下标的元素，直到后面下标元素之前
  print(str7[2:])
  print(str7[:13])

成员判断

print(“sunck” in str9)

常用转义字符

• \n 换行符
• \t 横向制表符
• \ 反斜杠
• " 双引号
• ’ 单引号
  注意：如果字符串里面有很多字符需要转义，就需要加入很多\，为了简化，python允许使用r"“表示”"内部的字符串默认不转义

内置函数

• eval()

  • 原型：eval(str)
  • 功能：将字符串当成有效的表达式来求值并返回结果
  • 参数：
  • 注意：字符串中有非数字字符串会报错(表示的是变量则可以使用)

• len(string)

  • 原型：len(string)
  • 功能：返回字符串的长度(按字符个数计算)
  • 参数：

• lower()

  • 原型：lower()
  • 功能：将字符串中所有的大写英文字母转为小写
  • 参数：

• upper()

  • 原型：upper()
  • 功能：将字符串中所有的小写英文字母转为大写
  • 参数：

• swapcase()

  • 原型：swapcase()
  • 功能：将字符串中的大写英文字母转小写，小写英文字母转大写
  • 参数：

• capitalize()

  • 原型：capitalize()
  • 功能：将字符串中第一个字符转为大写，其余转为小写
  • 参数：

• title()

  • 原型：title()
  • 功能：得到“标题化”的字符串，每个单词的首字符大写，其余小写
  • 参数：

• center(width[, fillchar])

  • 原型：center(width[, fillchar])
  • 功能：返回一个指定宽度width的居中字符串，fillchar为填充字符串，默认空格
  • 参数：

• ljust(width[, fillchar])

  • 原型：ljust(width[, fillchar])
  • 功能：返回一个指定宽度width的左对齐字符串，fillchar为填充字符串，默认空格
  • 参数：

• rjust(width,[, fillchar])

  • 原型：
  • 功能：返回一个指定宽度width的右对齐字符串，fillchar为填充字符串，默认空格
  • 参数：

• zfill (width)

  • 原型：
  • 功能：返回一个指定宽度width的右对齐字符串，默认使用0填充
  • 参数：

• count(str[, beg= 0,end=len(string)])

  • 原型：
  • 功能：返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内的出现次数,end默认为字符串的长度
  • 参数：

• find(str[, beg=0 end=len(string)])

  • 原型：
  • 功能：检测str是否包含在string中，如果包含返回第一个（从左侧开始找）出现的单词的下标，否则返回-1
  • 参数：

• rfind(str[, beg=0,end=len(string)])

  • 原型：
  • 功能：检测str是否包含在string中，如果包含返回第一个（从右侧开始找）出现的单词的下标，否则返回-1
  • 参数：

• index(str[, beg=0, end=len(string)])

  • 原型：
  • 功能：检测str是否包含在string中，如果包含返回第一个（从左侧开始找）出现的单词的下标，否则报异常
  • 参数：

• rindex(str[, beg=0, end=len(string)])

  • 原型：
  • 功能：检测str是否包含在string中，如果包含返回第一个（从右侧开始找）出现的单词的下标，否则报异常
  • 参数：

• strip([chars])

  • 原型：strip([chars])
  • 功能：在字符串上执行了lstrip和rstrip
  • 参数：

• lstrip()

  • 原型：lstrip([chars])
  • 功能：截掉字符串左侧指定的字符，默认为空格
  • 参数：

• rstrip()

  • 原型：rstrip([chars])
  • 功能：截掉字符串右侧指定的字符，默认为空格
  • 参数：

• split(str="", num=string.count(str))

  • 原型：
  • 功能：按照空格切割，得到一个列表，列表里每个单词的一个集合
  • 参数

• splitlines([keepends])
  -原型：

  • 功能：按照行(’\r’，’\r\n’，’\n’),如果keepends为False，不包含换行符，否则包含
  • 参数：

• join(seq)

  • 原型：join(seq)
  • 功能：返回一个新的拼接seq后的字符串
  • 参数：

• max(str)

  • 原型：
  • 功能：返回字符串中最大的字符
  • 参数：

• min(str)

  • 原型：
  • 功能：返回字符串中最小的字符
  • 参数：

• replace(old, new[, max])

  • 原型：
  • 功能：将字符串中的old替换为new，如果没有指定max值，则全部替换，如果指定了max值，则替换不超过max次
  • 参数：

• maketrans()

  • 原型：
  • 功能：创建字符映射的转换表，
  • 参数：
  • 示例：
    • t = str.maketrans(“un”, “ab”)
    • 输出：{117: 97, 110: 98}

• translate(table)

  • 原型：
  • 功能：根据str给出的表转换字符串
  • 参数：
  • 示例：
    • str42 = “sunck is a good man”
    • print(str42.translate(t))
    • 输出：sabck is a good mab

• isalpha()
  原型：
  功能：如果字符串至少有一个字符串并且所有的字符都是字母返回真，否则返回假
  参数：

• isalnum()
  原型：
  功能：如果字符串至少有一个字符串并且所有的字符都是字母或数字返回真，否则返回假
  参数：

• isupper()
  原型：
  功能：如果字符串至少有一个字符串并且所有的字母都是大写字母返回真，否则返回假
  参数：

• islower()
  原型：
  功能：如果字符串至少有一个字符串并且所有的字母都是小写字母返回真，否则返回假
  参数：

• istitle()
  原型：
  功能：如果字符串是标题化的返回真，否则返回假
  参数：

• isdigit()
  原型：
  功能：如果字符串只包含数字返回真，否则返回假
  参数：

• isnumeric()
  原型：
  功能：如果字符串只包含数字返回真，否则返回假
  参数：

• isdecimal()
  原型：
  功能：检测字符串是否只含十进制数字
  参数：

• isspace()
  原型：
  功能：如果字符串只含有空格返回真，否则返回假
  参数：

• startswith(str[, beg=0,end=len(string)])
  原型：
  功能：检测字符串是否以str开头，是则返回真，否则返回假。可以指定范围
  参数：

• endswith(suffix[, beg=0, end=len(string)])
  原型：
  功能：检测字符串是否以str结尾，是则返回真，否则返回假。可以指定范围
  参数：

• encode(encoding=‘UTF-8’,errors=‘strict’)
  原型：
  功能：以encoding指定的编码格式进行编码，如果出错包一个ValueError的异常，除非errors指定的是igonre或者replace
  参数：

• bytes.decode(encoding=“utf-8”, errors=“strict”)
  原型：
  功能：以encoding指定的格式进行解码
  参数：

• ord()
  原型：
  功能：获取字符的整数表示
  参数：

• chr()
  原型：
  功能：把数字编码转为对应的字符
  参数：

• str()
  原型：
  功能：转成字符串
  参数：

字符串比较大小

原理：按顺序从两个字符串中从左侧开始获取字符，比较两个字符如果谁大那么就是哪个字符串大，如果相等，继续比较下一个。

布尔值和空值

空值

是python中一个特殊的值，用None表示。
注意：None不能理解为0，因为0是有意义的，而None是没有任何实际意义的
作用：定义变量时，不知道初始值要赋值成什么数据，那么就设置为None，当你有确定值时在进行赋值操作。

布尔值

一个布尔类型的变量只有True、False两种值
作用：作为真假的判断

列表

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

创建列表

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

• 创建空列表
  list1 = []
  print(list1, type(list1))
• 创建带有元素的列表
  • 注意：列表中的元素的数据类型可以不同，但是实际开发中列表中一般存的都是相同类型的数据

•   flag = True
    list2 = [1,4,7,2,8,'good', flag, [5,6,7]]
    print(list2, type(list2))
  

列表的操作

• 添加元素：列表名.append(值) 向列表的末尾添加元素
• 修改：列表名[下标] = 值
• 取值：列表名[下标]
• 列表截取
  • list8 = [1,2,3,4,5,6,7,8,9,10]
    print("* =", list8[2:5])
    print("* =", list8[2:])
    print("* =", list8[:5])
    -1表示的是最后一个元素的下标， -2
• 列表组合
  list5 = list3 + list4
• 列表重复
  print(list6 * 3)
• 判断元素是否存在
  • list7 = [1,2,3]
    print(1 in list7)
• 二维列表：列表中的元素是一维列表
  • 本质：一维列表
  • list9 = [[1,2,3],
    [4,5,6],
    [7,8,9]]

列表的方法

• 1、 append(obj)
  在列表的末尾添加一个新的元素
• 2、extend(seq)
  在列表的末尾一次性追加多个元素
• 3、insert(index, obj)
  将元素按下标插入列表，不会覆盖原数据，原数据按顺序后移
• 4、pop(index=-1)
  移除列表中指定下标处的元素，默认删除最后一个。并返回删除的元素的值
• 5、 remove(obj)
  移除列表中的某个元素的第一个匹配项
• 6、 clear()
  清空列表
  -7、count(obj)
  统计某个元素在列表中出现的次数
• 8、index(obj)
  从列表中找出某个元素第一个匹配项的下标
• 9、len(list)
  返回列表中元素的个数
• 10、max(list)
  返回列表中元素的最大值
• 11、min(list)
  返回列表中元素的最小值
• 12、reverse()
  倒序列表中的元素
• 13、sort([func])
  列表排序，默认升序排序
  func的作用是规定排序的规则
• 14、list(seq)
  将其他集合(字符串、元组、集合）类型数据转为列表类型

深拷贝与浅拷贝

可视化内存执行过程

• ==与is
  • ==：判断值是否相等
  • is：判断的是内存地址
• 小整数对象
  小整数对象[-5, 256]:解释器预制在内存中的数据，引用小整数的变量的地址都是一样的，说明引用的是同一片内存
• 深拷贝
  • 深浅拷贝的区别的前提是列表中要有其他列表元素
    • 赋值

    c = [1,2,3,4,5,[6,7,8]]
    d = c
    print(c == d)
    print(c is d)
    c[5][1] = 70
    print(c, d)
    print(id(c), id(d))			内存地址一样
    print(id(c[5]), id(d[5]))		内存地址一样
    

    • 浅拷贝 只拷贝表层元素

    from copy import copy, deepcopy
    e1 = [1,2,3,4,5,[6,7,8]]			#内存地址不一样
    f1 = copy(e1)
    print(id(e1), id(f1))
    print(e1 == f1)
    print(e1 is f1)
    print(id(e1[5]), id(f1[5]))		#内存地址一样
    

    • 深拷贝 在内存中重新创建所有的子元素

    g1 = [1,2,3,4,5,[6,7,8]]				
    h1 = deepcopy(g1)
    print(id(g1), id(h1))				#内存地址不一样
    print(g1 == h1)
    print(g1 is h1)
    print(id(g1[5]), id(h1[5]))				#内存地址不一样
    

元组

• 本质：有序的集合
• 特性：
  1、与列表非常相似
  2、一旦初始化就不能修改
  3、使用小括号
• 创建元组
  格式：元组名 = (元组选项1, 元组选项2, ……, 元组选项n)
  • 创建空元组
    tup1 = ()
    print(tup1)
  • 创建带元素的元组，元组的元素类型可以不同
    tup2 = (1,2,3,4,5,“good”)
    print(tup2)
  • 定义含有一个元素的元组，需要加一个逗号
    tup3 = (1,)
    print(tup3, type(tup3))

元组元素的访问

1、取值 	 元组名[下标]
2、元组是不能修改的，但是元素如果是列表类型，那么列表中的元素可以修改
3、示例：tup4 = (1,2,3,4,5,6,7,8,9,10)
print(tup4[3])
#print(tup4[13]) # 下标越界
print(tup4[-1])

元组的操作

tup6 = (1,2,3)
tup7 = (4,5,6)

• 拼接 tup8 = tup6 +tup7
  print(tup6, tup7, tup8)
• 重复 tup9 = tup6 * 3
  print(tup6, tup9)
• 元组的截取
  print(tup10[1:5])
  print(tup10[1:])
  print(tup10[:5])
  print(tup10[1:-2])

元组的操作方法

• len(tuple) 返回元组中的元素个数
• max(tuple）
• min(tuple）
• tuple(seq) 将集合转为元组类型
• 元组对称赋值
  • num1, num2 = (1, 2)
    print(num1, num2)

字典

• 概述：
  1、使用键值对(key-value)的形式存储数据，具有极快的查速度

• key的特性：

  • 1、字典中的key必须唯一
  • 2、key必须是不可变对象
    • a、字符串、数字都是不可变的，可以作为key（一般为字符串）
    • b、列表时可变的，不能作为key
  • 3、键值对是无序的

• 创建字典存储一个学生的信息

  • 格式：{key1:value1, key2:value2, ……, keyn:valuen}

• 访问字典的值

  • 获取:字典名[key] 获取不存在的键的值报错
  • 获取:字典名.get(key) 获取不存在的键的值，得到None

• 添加键值对

  • stu3[“nikeName”] = “**”
    print(stu3)

• 删除键值对
  stu3.pop(“nikeName”)
  print(stu3)

• 遍历

  • 方法1（获取键和值）
    for key in stu4:
    print(key, stu4[key])
  • 方法2（获取值）
    for value in stu4.values():
    print(value)
  • 方法3（获取键和值）
    for key, value in stu4.items():
    print(key, value)
  • 方法4（获取下标和值）
    for index, key in enumerate(stu4):
    print(index, key)

  比较list和dict

• dict：

  • 优点：查找和插入的速度极快，不会随着key的增多而降低效率
  • 缺点：需要占用大量的内存，内存浪费过多

• list：

  • 优点：占用的内存空间小，浪费内存很少
  • 缺点：查找和从插入的效率会随着元素的增多而变慢

set集合

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

• 本质：无序和无重复的集合
• 创建：需要用一个list或者tuple作为输入集合
  s1 = set([1,2,3,4,5,3,5,6,7,“good”,(8, 9)])
  print(s1)
  s2 = set((8, 9, 10))
  print(s2)
  s3 = set(“fuck”)
  print(s3)
• 作用：列表去重
• 操作
  • 添加
    s4 = set([1,2,3,4,5])
    s4.update([(6,7,8)])
  • 删除
    • 从左侧开始删除
      print(s5.pop())
    • 删除对应元素，如果元素不存在会报KeyError的异常
      s5.remove(5)
• 遍历
  for index, key in enumerate(s6):
  print(index, key)
• 交叉并集
  s7 = set([1,2,3])
  s8 = set([2,3,4])
  • 交集
    print(s7 & s8)
  • 并集
    print(s7 | s8)

类型转换

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

• list、tuple、string —> set

set()

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

流程控制

if语句

• 格式
  if 表达式:
  语句
• 逻辑：当程序执行到if语句时，首先会计算“表达式”的值。如果“表达式”的值为真，则执行“语句”。如果“表达式”的值为假，那么则结束整个if语句继续向下执行

if-else语句

• 格式：
  if 表达式:
  语句1
  else:
  语句2
• 逻辑：当程序执行到if-else语句时，首先会计算“表达式”的值。如果“表达式”的值为真则执行“语句1”，执行完则结束整个if-else语句继续向下执行。如果“表达式”的值为假则执行“语句2”，执行完则结束整个if-else语句继续向下执行。

if-elif-else语句

• 格式
  if 表达式1:
  语句1
  elif 表达式2:
  语句2
  elif 表达式3:
  语句3
  ……
  elif 表达式n:
  语句n
  else:
  语句e

注意：最后的else部分可有可无

• 逻辑：当程序执行if-elif-else语句时，首先计算“表达式1”的值，如果“表达式1”的值为真则执行“语句1”，执行完则结束整个if-elif-else语句继续向下执行。如果“表达式1”的值为假则计算“表达式2”的值，如果“表达式2”的值为真则执行“语句2”，执行完则结束整个if-elif-else语句继续向下执行。如果“表达式2”的值为假则计算“表达式3”的值，如此直到遇到某个“表达式”的值为真才结束。如果没有“表达式”为真且存在else语句则执行“语句e”，执行完结束整个if-elif-else语句继续向下执行。
  精髓：每一个else都是对它上面所有表达式的否定

循环语句

while 循环

• 格式
  while 表达式:
  语句

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

• 死循环：表达式永远为真的循环
  开发当中尽量少用死循环
  用死循环时尽量添加延时

• while语句中使用else语句

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

• 逻辑：在“表达式”的值为假时执行else语句中的“语句2”

for循环

• 格式
  for 变量名 in 集合:
  语句
• 逻辑：当程序执行到for语句时，按顺序获取“集合”中的每个元素，“变量”表示当前循环获取到的元素值，在执行语句。如此循环往复，直到取完“集合”中的元素才停止
• range()方法
  功能：生成列表
  • 使用1：range(num)
    range(5) #0 1 2 3 4
  • 使用方式2：range([startNum, ]stopNum[, stap])
    startNum默认为0，stap默认为1
• 同时遍历元素与下标
  enumerate(seq)每次循环返回是一个元组，元组的第一个元素为下标，第二个元素为集合的元素值
  for index, word in enumerate(list1): #index, word = (0, “good”)
  print(word, index)

pass,break,continue

pass

• 作用：当语句要求不希望任何命令或代码来执行
• 说明：pass语句表示一个空操作，在执行时没有任何的响应，pass的位置最终应该有代码执行的，但是暂时写不出来
• 说明：可以用在流程控制和循环语句中

break语句

• 作用：跳出循环
• 注意：只能跳出距离最近的for或者while循环
• while循环语句可以有else子句，表达式为假时会被执行，但是使用break终止循环后else中的语句不执行

continue语句

• 作用：跳过本次循环后面的剩余语句，然后继续下一次循环
• 注意：
• 语句可以进行嵌套，循环语句的嵌套不要太深，一般3层，最好不要超过6层