Python 快速入门 – 变量

代码格式

• python 不限制缩进空格数，但是同一个代码块缩进空格数要相等
• 建议使用4个空格
• 可以使用;在同一行显示多个语句
• 多行语句换行用\
  • 在[] {} ()中的多行语句不用使用\换行
• 单行注释用#,多行注释用'''或者"""

python 标识符

• 标识符由字母、数字、下划线(_)组成
• 所有标识符可以包括英文、数字以及下划线，但不能以数字开头
  • 可以使用汉字（非ASCII码适用）
• 标识符区分大小写
• 以下划线开头的标识符有特殊意义
  • 以单下划线开头代表不能直接访问的类属性
  • 以双下划线开头代表类的私有成员
  • 以双下划线开头和结尾代表 python 里特殊方法专用的标识

__len__
__item__

python 变量

• 变量不需要声明
• 每个变量在使用前都必须赋值（赋值后才会被创建）
• python 是动态变量类型的语言
• del删除对象引用
  • 删除后不能再次引用，除非再次赋值
• id(var)获取变量所指对象的内存地址

>>>a = 2
>>>del a
>>>print(id(2))
4422478208
>>>c = 2
>>>print(id(c))
4422478208

python 数据类型

标准数据类型：

• Number：数字类型 int, bool, float, complex
• String：字符串 str
• List：列表 list
• Tuple：元组
• Set：集合set()
• Dictionary：字典 dict

类型的划分

不可变数据

• Number：数字类型 int, bool, float, complex
  • int 整数；长整型
  • bool 布尔型：True和False type(True)和isinstance(True, int)的返回结果？
  • float浮点数：3.14
  • complex复数：1+3j
    • complex:a + bj，或者complex(a, b)表示， 复数的实部a和虚部b都是浮点型
    python 没有 double
• String：字符串 str

Tuple：元组

• 使用不可变类型当作key

可变数据

• List：列表 list
• Dictionary：字典 dict
• Set：集合set()

类型的查询

• type() 可以用来查询变量所指的对象类型
  • 有时的操作只能对特定类型进行操作，所以
• type() 不会认为[子类是一种父类类型]
  • e.g. 学生是人，但type(.学生)=学生，不是人

type(True)和isinstance(True, int)的返回结果？

类型的判断

• ****可以用来判断是否是某类型
• isinstance()会认为[子类是一种父类类型]

type(True)和isinstance(True, int)的返回结果？

print(type(True))
>>><class 'bool'>
print(isinstance(True, int))
>>>True
print(isinstance(123.2, int))
>>>False  

Number：数字类型 int, bool, float, complex

• int 整数；长整型
• bool 布尔型：True和False type(True)和isinstance(True, int)的返回结果？
• True和False关键字的值是0和1，可以与数字相加
  • python里if -1 / if 2都是True，if 0是假
• float浮点数：3.14
• complex复数：1+3j
  • complex:a + bj，或者complex(a, b)表示， 复数的实部a和虚部b都是浮点型
  python 没有 double

Number：数字类型 int, bool, float, complex

• int 整数；长整型
• bool 布尔型：True和False type(True)和isinstance(True, int)的返回结果？
• True和False关键字的值是0和1，可以与数字相加
  • python里if -1 / if 2都是True，if 0是假
• float浮点数：3.14
• complex复数：1+3j
  • complex:a + bj，或者complex(a, b)表示， 复数的实部a和虚部b都是浮点型
  python 没有 double

数据类型不允许改变,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

>>>x = 20
>>>y = 20
>>>print(id(x))
4546468800
>>>print(id(y))
4546468800 

🗓️为提高内存利用效率,对于简单对象如int对象或字符串对象等，会采取重用对象内存的办法

• 比较操作可以传递a < b == c

数字类型的运算

• True和False关键字的值是0和1，可以与数字相加
  • python里if -1 / if 2都是True，if 0是假
• /为除法，得到浮点数
• //为除法，得到整数（不一定，分子分母为浮点时得到浮点）
• **幂运算
• complex:a + bj，或者complex(a, b)表示， 复数的实部a和虚部b都是浮点型

String：字符串 str

• 单引号和双引号使用完全相同
• 使用'''或"""可以指定一个多行字符串
• 转义符\
  • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义

>>>print("\n")
>>>print(r"\n")
\n

• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
• 字符串可以用+运算符连接在一起，用*运算符重复
• 字符串的结尾字符是？

String：字符串 str

• 单引号和双引号使用完全相同
• 使用'''或"""可以指定一个多行字符串
• 转义符\
  • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义

>>>print("\n")
>>>print(r"\n")
\n

• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string
• 字符串可以用+运算符连接在一起，用*运算符重复
• 字符串的结尾字符是？

字符串的索引

• 从左到右：以0开始
• 从右到左：以-1开始
• 字符串不能改变

>>> s = 'a'
>>> print(id(s))
140685120612400
>>> s += 'b
>>> print(id(s))
140685121524912

• 没有单独的字符类型，一个字符就是长度为1的字符串

字符串常用函数

• find()检索，返回位置，找不到返回-1
• strip()
• split()
  • 默认是使用空格进行分割
• zfill(width)在字符串填充0

List：列表 list

• 使用最频繁到数据类型
• 有步长的元素截取重点[151]02 列表有开始、结束、步长值3个参数，我们可以将这三个参数在中括号中指定，用冒号字符分隔。
  如果没有指定开始值，则默认为0；
  如果没有指定结束值，则取列表允许的最大值；
  如果没有指定步长值，则默认值为1；

结束值表示直到但不包括

List：列表 list

• 使用最频繁到数据类型
• 有步长的元素截取 列表有开始、结束、步长值3个参数，我们可以将这三个参数在中括号中指定，用冒号字符分隔。
  如果没有指定开始值，则默认为0；
  如果没有指定结束值，则取列表允许的最大值；
  如果没有指定步长值，则默认值为1；

结束值表示直到但不包括

基本操作

>>> list1=['a','b','c']
>>> list2=['d','e','f']
>>> print(list1*2)
['a', 'b', 'c', 'a', 'b', 'c']
>>> print(list1+list2)
['a', 'b', 'c', 'd', 'e', 'f']
>>> list1[1:4:2]
['b'] 

>>> nl=[0,1,2,3,4,5,6,7,8,9,10]
>>> print(nl[0::2])
[0, 2, 4, 6, 8, 10]
>>> print(nl[::2])
[0, 2, 4, 6, 8, 10] 

>>> mylist
['w', 'a', 's', 'a', 'b', 'i']
>>> mylist[0: 5: 2]
['w', 's', 'b']
>>> mylist[3::]
['a', 'b', 'i']
>>> mylist[:5:]
['w', 'a', 's', 'a', 'b']
>>> mylist[::2]
['w', 's', 'b']

列表的逆序

>>> ll=['A', 'B', 'C', 'D', 'E', 'F', 'G']
>>> print(ll[-1::-1])
['G', 'F', 'E', 'D', 'C', 'B', 'A']
>>> print(ll.reverse())
None
>>> print(ll)
['G', 'F', 'E', 'D', 'C', 'B', 'A']

元素的删除

• del语句：删除某个索引值对应的元素，或删除整个列表变量

>>> ll=['A','B','C','D','E','F','G']
>>> del ll[0]
>>> print(ll)
['B', 'C', 'D', 'E', 'F', 'G'] 

>>> del ll
>>> print(ll)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'll' is not defined

• remove()语句：删除某个特定元素

>>> ll=['A','B','C','D','E','F','G']
>>> ll.remove('A')
>>> print(ll)
['B', 'C', 'D', 'E', 'F', 'G']

• a.clear()相当于del a[:]

>>> ll.clear()
>>> print(ll)
[]

元素的增加

• append()会把对象整体添加到列表后，效率极低

>>> ll=['A','B','C','D','E','F','G']
>>> lr=['H', 'I', 'J']
>>> ll.append(lr)
>>> print(ll)
['A', 'B', 'C', 'D', 'E', 'F', 'G', ['H', 'I', 'J']]

• ****会把对象迭代后添加到列表后

>>> ll=['A','B','C','D','E','F','G']
>>> ll.extend(lr)
>>> print(ll)
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']

列表的排序

• sort()排序

>>> a
[1, 2, 3, 5, 7, 4]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 7]
>>> b = ['2', 'd', '5']
>>> b.sort()
>>> b
['2', '5', 'd'] 

列表的复制

• a.copy()相当 a[:]
• slice copy 在可能对原列表有修改的操作中较常见

列表的推导式

>>> a=[x**2 for x in range(6)]
>>> a
[0, 1, 4, 9, 16, 25]

>>> a=list(map(lambda x:x**2,range(6)))
>>> a
[0, 1, 4, 9, 16, 25]

>>> a=[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
>>> a
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

压平列表

>>> ll=[[1,3,4],[5,6,7,8],[9,10,11]]
>>> ll_f=[e for ele in ll for e in ele]
>>> ll_f
[1, 3, 4, 5, 6, 7, 8, 9, 10, 11]

矩阵交换行列

>>> matrix=[[1,1,1],[2,2,2],[3,3,3]]
>>> matrix2=[[row[i] for row in matrix] for i in range(3)]
>>> matrix2
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]

列表的内存分配

>>> L=[1,2,3]
>>> L2=[1,2,3]
>>> id(L)
140685121526592
>>> id(L2)
140685121536384
>>> L1=L[:]
>>> id(L1)
140685121537024
>>> L3 = L
>>> id(L3)
140685121526592
----------------
id(L) == id(L3)
id(L1)
id(L2) 

Tuple：元组

• 与列表相似，不同之处在于元素不可修改
  • 字符串看作特殊元组
• 虽然元素不可改变，但是可以包含可变的对象

Tuple：元组

• 与列表相似，不同之处在于元素不可修改
  • 字符串看作特殊元组
• 虽然元素不可改变，但是可以包含可变的对象

>>> a = [1, 2]
>>> b = [3, 4]
>>> c = (a, b)
>>> c
([1, 2], [3, 4])
>>> a = [3, 4]
>>> c
([1, 2], [3, 4])
>>> c = (a, b)
>>> c
([3, 4], [3, 4])

🗓️虽然元组可包含可变的对象,但是为元组赋值时,可变的变量只是单方面的赋给了元组,当这些可变变量改变时,元组并不发生改变；

🗓️元组被再次进行赋值时，其内部变量值才会改变。

• 构造包含 0 个或 1 个元素的元组

tup1=() #空元组  
tup2 = (20,) # 一个元素，需要在元素后添加逗号，否则含义不明确

• 元组中的元素值不允许删除，但del能删除整个元组

Set：集合set()

• 集合一般用于进行成员关系测试和删除重复元素
• 创建非空集合：{}, set()
• 创建空集合：set()
  • {}用于创建空字典

Set：集合set()

• 集合一般用于进行成员关系测试和删除重复元素
• 创建非空集合：{}, set()
• 创建空集合：set()
  • {}用于创建空字典

集合的运算

• -差运算
• |并运算
• &交运算
• ^对称差运算：仅仅存在于 s 和 t 二者之一中的元素
• (|-&)
• update()批量添加元素

集合的实现

• 散列实现
  • b不能有可变类型

Dictionary：字典 dict

• 一种映射类型，其元素是键值对
• 是无序的键(key):值(value)集合
  • key必须使用不可变类型
  • 同一字典中的key必须是唯一的

Dictionary：字典 dict

• 一种映射类型，其元素是键值对
• 是无序的键(key):值(value)集合
  • key必须使用不可变类型
  • 同一字典中的key必须是唯一的
• 函数 dict()可以直接从键值对序列中构建字

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> dict(list(enumerate(['one','two','three'],start=1)))
{1: 'one', 2: 'two', 3: 'three'} 

• 有序输出

for key in sorted(dic.keys()):
print(key,dic[key])

• 构建有序字典（对字典排序）

import collections
dic = collections.OrderedDict()
dic = collections.OrderedDict(sorted(un sorted_d.items(), key=lambda dc:dc[1], reverse = True))

判断相等

• is运算符
  • a is b相当于id(a) == id(b)

‼️is用于判断两个变量引用对象是否为同一个
==用于判断引用变量的值是否相等

强制类型转换

序号	语句	描述
1	int(x [,base])	将x转换为一个整数
2	float(x)	将x转换到一个浮点数
3	complex(real [,imag])	创建一个复数
4	str(x)	返回对象x的字符串表达
5	repr(x)	返回对象x的字符串表达
6	eval(str)	用来计算在字符串中的有效python表达式，并返回一个对象
7	tuple(s)	将序列s转换为一个元组
8	list(s)	将序列s转换为一个列表
9	set(s)	转换为可变集合
10	dict(d)	创建一个字典，d必须是一个(key, value)元组序列。
11	frozenset(s)	转换为不可变集合待掌握[151]02
12	chr(x)	将一个整数转换为一个字符
13	ord(x)	将一个字符转换为它的整数值
14	hex(x)	将一个整数转换为一个十六进制字符串

随机数函数

序号	语句	描述
1	choice(seq)	从序列中随机挑选一个元素
2	randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取
一个随机数，基数默认值为1
3	random()	随机生成下一个实数，在[0,1)范
围内
4	seed([x])	改变随机数生成器的种子seed
5	shuffle(list)	将序列的所有元素随机排序
6	uniform(x, y)	随机生成下一个实数，在[x,y]范围内