python 变量以及变量的类型
- 1. 变量的概念
- 2. 变量的赋值
- 2.1 单个变量赋值
- 2.2 多个变量赋值
- 2.3 为多个对象指定多个变量
- 3. 变量的类型
- 3.1 在内存中创建一个变量,会包括
- 3.2 判断变量的类型
- 3.3 删除一个变量
- 3.4 Python3 中六个标准的数据类型
- 3.5 可变数据类型和不可变数据类型
- 4. 数字类型(number)
- 4.1 int(整形)
- 4.2 float(浮点型)
- 4.3 bool(布尔型)
- 4.4 complex(复数)
- 4.5 数据类型转换
- 5. 字符串(string)
- 5.1 可以使用单引号或双引号创建字符串
- 5.2 字符串运算符
- 5.3 格式化字符串
- 5.4 Unicode 字符串
- 5.5 python 的字符串内建函数
- 6. 列表(list)
- 6.1 说明
- 6.2 访问列表中的元素
- 6.3 更新列表中的元素
- 6.4 删除列表中的元素
- 6.5 列表中的 `+, *, in, not in`
- 6.6 列表截取
- 6.7 列表中嵌套其他数据类型的数据
- 6.8 列表推导式
- 6.9 列表常用函数和方法
- 7. 元组(tuple)
- 7.1 说明
- 7.2 元组的取值,截取,方法等操作都与列表一样
- 7.3 元组中的元素不能修改
- 8. 字典(dict)
- 8.1 说明
- 8.2 创建一个字典
- 8.3 获取字典中的数据
- 8.4 修改字典中的数据
- 8.5 删除字典中的数据
- 8.6 字典常用函数和方法
- 9. 集合
- 9.1 说明
- 9.2 集合运算
- 9.3 集合添加元素
- 9.4 集合删除元素
- 9.5 清空集合
- 9.6 其他常用函数
1. 变量的概念
- 在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。
- 在 Python 中,变量不需要声明,但是 在使用前必须赋值,变量 赋值以后 该变量 才会被创建。
- 变量定义之后,后续就可以直接使用了。
2. 变量的赋值
- 等号(=)用来给变量赋值。
-
=
左边是一个变量名。 -
=
右边是存储在变量中的值。
2.1 单个变量赋值
age = 18 # 整型变量
money = 14.5 # 浮点型变量
name = "xiaolizi" # 字符串
2.2 多个变量赋值
# 下面示例会先创建一个整型对象,值为 1。然后从后向前赋值,三个变量被赋予相同的数值。
a = b = c = 1
2.3 为多个对象指定多个变量
# 注意两边都是用逗号分隔
a, b, c = 1, 2, 3
3. 变量的类型
3.1 在内存中创建一个变量,会包括
- 变量的名称
- 变量保存的数据
- 变量存储数据的类型
- 变量的地址(标识)
3.2 判断变量的类型
- type() 函数
num = 1
str = '小李子'
print(type(num))
print(type(str))
out:
<class 'int'>
<class 'str'>
- isinstance() 函数
a = 2
print(isinstance(a, int))
out:
True
- isinstance 和 type 的区别:
- type() 不会认为子类是一种父类类型。
- isinstance() 会认为子类是一种父类类型。
# 所有的类都是 object 的子类
print(type(int) == object)
print(isinstance(int, object))
out:
False
True
3.3 删除一个变量
a = 1
str = '小李子'
# 单个删除
del a
del str
# 批量删除
del a, str
3.4 Python3 中六个标准的数据类型
- Number(数字)
- String(字符串)
- List(列表)
- Tuple(元组)
- Set(集合)
- Dictionary(字典)
3.5 可变数据类型和不可变数据类型
Python3 的六个标准数据类型又分为两类:
- 不可变数据类型(3 个):Number(数字)、String(字符串)、Tuple(元组)。
- 可变数据数据类型(3 个):List(列表)、Dictionary(字典)、Set(集合)。
4. 数字类型(number)
4.1 int(整形)
Python3中,只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
可以使用十六进制(0x 开头)和八进制(0o 开头)来代表整数。
print(0xff) # 两位16进制能表示的最大数
print(0o77) # 两位八进制能表示的最大数
out:
255
63
4.2 float(浮点型)
# 科学计数法表示浮点数
print(1.2e3)
out:
1200.0
4.3 bool(布尔型)
Python3 中,把 True 和 False 定义成关键字了,但它们的值还是 1 和 0,它们可以和数字相加。
4.4 complex(复数)
复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
print(1 + 2j)
print(complex(1, 2))
out:
(1+2j)
(1+2j)
4.5 数据类型转换
* int(x):将x转换为一个整数。
* float(x):将x转换到一个浮点数。
* complex(x):将x转换到一个复数,实数部分为 x,虚数部分为 0。
* complex(x, y):将 x 和 y 转换到一个复数,实数部分为 x,虚数部分为 y。x 和 y 是数字表达式。
5. 字符串(string)
5.1 可以使用单引号或双引号创建字符串
str01 = 'xiaolizi'
str02 = "huge"
5.2 字符串运算符
a = 'Hello'
b = 'Python'
操作符 | 描述 | 实例 |
+ | 字符串连接 | a + b 输出:HelloPython |
* | 重复输出字符串 | a*2 输出:HelloHello |
[] | 通过索引获取字符串中字符 | a[1] 输出:e |
[ : ] | 截取字符串中的一部分,遵循左闭右开原则,str[0:2] 是不包含第 3 个字符的。 | a[1:4] 输出:ell |
in | 成员运算符 - 如果字符串中包含给定的字符返回 True | ‘H’ in a 输出:True |
not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | ‘M’ not in a 输出:True |
r/R | 原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。 | print( r’Hello\nWorld’ ) 输出:Hello\nWorld |
5.3 格式化字符串
5.4 Unicode 字符串
在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中,所有的字符串都是Unicode字符串。
5.5 python 的字符串内建函数
6. 列表(list)
6.1 说明
python 中的列表类似 c 语言中的数组,但是列表的数据项不需要具有相同的类型。
创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。
与字符串的索引一样,列表索引从0开始。列表可以进行截取、组合等。
list = [1, 2, 'a', 'b', True, False]
6.2 访问列表中的元素
list = [1, 2, 'a', 'b', True, False]
print(list[0]) # 访问list的第一个元素
print([list[1:3]) # 访问list的第二和第三个元素
out:
1
[2, 'a']
6.3 更新列表中的元素
list = [1, 2, 'a', 'b', True, False]
list[2] = 3
print(list) # [1, 2, 3, 'b', True, False]
6.4 删除列表中的元素
list = [1, 2, 'a', 'b', True, False]
del list[2]
print(list) # [1, 2, 'b', True, False]
del list # 删除列表
6.5 列表中的 +, *, in, not in
list01 = [1, 2]
list02 = [3, 4]
print(list01 + list02) # 组合 list01 和 list02
print(list01 * 2) # 重复 list01 两次
print(1 in list01) # 判断某个元素是否在列表中
print(1 not in list02) # 判断某个元素是否不在列表中
out:
[1, 2, 3, 4]
[1, 2, 1, 2]
True
False
6.6 列表截取
使用格式:list[start : end : stepLen]
- start:可选参数,开始的索引位置,闭区间
- end:可选参数,结束的索引位置,开区间
- stepLen:可选参数,步长,如果为负数,则反向截取
list = [1, 2, 3, 4, 5, 6, 7, 8]
# 一个参数
print(list[0]) # 根据下标输出列表中的元素,下标从零开始
print(list[-1]) # -1 表示列表中最后一个元素,以此类推 -2, -3
# 两个参数
print(list[0:]) # 从第一个元素开始,截取到最后一个元素
print(list[:-1]) # 从第一个元素开始,截取到倒数第二个,因为第二个参数是开区间
print(list[:]) # 截取所有元素
# 三个参数
print(list[::2]) # 第三参数为正数,表示从前往后截取;步长为2,表示每隔一个元素截取一次;省略了第一和第二个参数,所以在整个列表范围内截取
print(list[::-1]) # 第三参数为负数,表示从后往前截取;步长是 1,表示每个元素都要截取;省略了第一和第二个参数,所以在整个列表范围内截取
out:
1
8
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 3, 5, 7]
[8, 7, 6, 5, 4, 3, 2, 1]
6.7 列表中嵌套其他数据类型的数据
列表中可以嵌套列表,元组,字典等等。
# 列表中嵌套列表,相当于二维数组
list = [[1, 2], [3, 4]]
# 列表中嵌套元组
list = [(1, 2), (3, 4)]
# 列表中嵌套字典
list = [{'a': 1}, {'b': 2}]
6.8 列表推导式
list = [x for x in 'abcdefg' if x not in 'cde'] # ['a', 'b', 'f', 'g']
6.9 列表常用函数和方法
7. 元组(tuple)
7.1 说明
Python 的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号,列表使用方括号。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
# 创建一个空元祖
tup = ()
print(type(tup)) # <class 'tuple'>,type()函数返回变量的数据类型
# 或者
tup = tuple()
print(type(tup)) # <class 'tuple'>,type()函数返回变量的数据类型
# 用小括号创建一个元组
tup = (0, 'a', [1, 2])
# 也可以不用括号
tup = 1, 2, 3
- 注意:
元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用
tup01 = ('a')
print(type(tup01)) # <class 'str>
tup02 = ('a',)
print(type(tup02)) # <class 'tuple'>
7.2 元组的取值,截取,方法等操作都与列表一样
7.3 元组中的元素不能修改
不能修改或删除元组中的元素,但是可以将元组整个删除,或者重新赋值。
当元素是可变对象时,对象内部属性是可以修改的。
tup = (1, 2, 3)
tup = (4, 5, 1) # 可以重新对元组变量赋值,改变指向
del tup # 也可以直接删除元组变量
# 当元素是可变对象时,对象内部属性是可以修改的
tup = (1 , 2, [3, 4])
tup[2][0] = 5
tup[2][1] = 6
print(tup) # (1 , 2, [5, 6]),表面上元组改变了,实际上改变的是元组中列表中的值,列表指向的内存地址并没有变,所以元组也没有改变
8. 字典(dict)
8.1 说明
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号(:)分割,每个键值对之间用逗号(,)分割,整个字典包括在花括号 {} 中。
- 注意:
- 键必须是唯一的,但值则不必。如果键不唯一,创建时,后面的会覆盖面的。
- 值可以取任何数据类型,但键必须是不可变数据类型,如字符串,数字,元组。
- Python 3.6 改写了 dict 的内部算法,因此 3.6 的 dict 是有序的,在此版本之前皆是无序
8.2 创建一个字典
# 创建一个空字典
dict01 = dict()
# 创建一个字典
dict02 = {'one': 1, 2: 'two', (1, 2): 3}
8.3 获取字典中的数据
dict = {'a': 1, 'b': 2, 'c': 3}
dict['a'] # 1
dict['d'] # KeyError: 'd',没有这个key值就会报错
8.4 修改字典中的数据
dict = {'a': 1, 'b': 2, 'c': 3}
# 修改数据
dict['a'] = 0 # {'a': 0, 'b': 2, 'c': 3}
# 增加数据
dict['d'] = 4 # {'a': 0, 'b': 2, 'c': 3, 'd': 4}
8.5 删除字典中的数据
dict = {'a': 1, 'b': 2, 'c': 3}
del dict['a'] # {'b': 2, 'c': 3}
del dict # 删除字典
8.6 字典常用函数和方法
9. 集合
9.1 说明
集合(set)是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合。
- 注意:
创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
set01 = {1, 2, 3}
# 或者
set02 = set([1, 2, 3]) # set() 函数只接收一个参数,初始化时可以传入一个列表或元组
9.2 集合运算
a = {'a', 'c', 'd', 'b', 'r'}
b = {'a', 'c', 'z', 'l', 'm'}
# 差集,集合a中包含而集合b中不包含的元素
# 1. 使用 - 运算符
print(a - b)
# 2. 或者 s1.difference(s2) 函数
print(a.difference(b))
# 并集,集合a或b中包含的所有元素
# 1. 使用 | 运算符
print(a | b)
# 2. 或者 s1.union(s2[, s3, s4]) 函数
print(a.union(b)) # 可以有多个参数
# 交集,集合a和b中都包含了的元素
# 1. 使用 & 运算符
print(a & b)
# 2. 或者 s1.intersection(s2[, s3, s4]) 函数
print(a.intersection(b)) # 可以有多个参数
# 对称差集,不同时包含于a和b的元素
# 1. 使用 ^ 运算符
print(a ^ b)
# 2. 或者 s1.symmetric_difference(s2) 函数
print(a.symmetric_difference(b))
out:
{'d', 'r', 'b'}
{'d', 'r', 'b'}
{'d', 'm', 'a', 'z', 'l', 'c', 'b', 'r'}
{'d', 'm', 'a', 'z', 'l', 'c', 'b', 'r'}
{'a', 'c'}
{'a', 'c'}
{'d', 'r', 'm', 'l', 'z', 'b'}
{'d', 'r', 'm', 'l', 'z', 'b'}
9.3 集合添加元素
- s.add(x)
将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。
只能添加不可变数据类型的数据,比如:字符串、元组、数字。
只有一个参数。
s = set([1, 2, 3])
s.add(1) # {1, 2, 3},不做任何操作
s.add((4, 5)) # {(4, 5), 1, 2, 3}
s.add([6, 7]) # 报错,TypeError: unhashable type: 'list'
- s.update(x)
向集合中添加元素,且参数可以是列表,元组,字典等。
参数可以有多个,用逗号分开。
s = set([1, 2, 3])
s.update(1) # 报错,TypeError: 'int' object is not iterable
s.update('ab') # {1, 2, 3, 'a', 'b'},将字符串中每个字符作为一个元素更新到集合中
s.update([4, 5], [6, 7]) # {1, 2, 3, 4, 5, 6, 7}
9.4 集合删除元素
- s.remove(x)
将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
s = set([1, 2, 3])
s.remove(1) # {2, 3}
s.remove(4) # 报错,KeyError: 4
- s.discard(x)
将元素 x 从集合 s 中移除,如果元素不存在,不会发生错误。
s = set([1, 2, 3])
s.discard(1) # {2, 3}
s.discard(4) # {1, 2, 3},不会报错
- s.pop()
随机删除集合中的一个元素,pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。
s = {1, 2, 3}
s.pop() # {2, 3}
9.5 清空集合
- s.clear()
s = {1, 2, 3}
s.clear() # set()
9.6 其他常用函数
- len(s)
返回集合中元素的个数。
s = {1, 2, 3}
len(s) # 3
- x in / not in s
判断元素 x 是否在集合 s 中。
s = {1, 2, 3}
print(1 in s) # True
print(4 not in s) # True
- s.copy()
浅拷贝一个集合
s = set([1, 2, 3])
sc = s.copy() # {1, 2, 3}
- s1.difference_update(s2)
用于移除两个集合中都存在的元素。
difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合,而 difference_update() 方法是直接在原来的集合中移除元素,没有返回值。
a = {'a', 'c', 'd', 'b', 'r'}
b = {'a', 'c', 'z', 'l', 'm'}
a.difference_update(b)
print(a) # {'b', 'r', 'd'}
- s1.set.intersection_update(s2[, s3, s4])
用于获取两个或更多集合中都重叠的元素,即计算交集。
intersection_update() 方法不同于 intersection() 方法,因为 intersection() 方法是返回一个新的集合,而 intersection_update() 方法是在原始的集合上移除不重叠的元素。
a = {'a', 'c', 'd', 'b', 'r'}
b = {'a', 'c', 'z', 'l', 'm'}
a.intersection_update(b)
print(a) # {'a', 'c'}
- s1.symmetric_difference_update(s2)
移除 s1 集合中与 s2 集合相同的元素,并将 s2 集合中不同的元素插入到 s1 集合中。
a = {'a', 'c', 'd', 'b', 'r'}
b = {'a', 'c', 'z', 'l', 'm'}
a.symmetric_difference_update(b)
print(a) # {'l', 'd', 'r', 'b', 'm', 'z'}
- s1.isdisjoint(s2)
判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。
a = {'a', 'c', 'd', 'b', 'r'}
b = {'a', 'c', 'z', 'l', 'm'}
print(a.isdisjoint(b)) # False
- s1.issubset(s2)
判断集合 s1 的所有元素是否都包含在 s2 集合中,如果是则返回 True,否则返回 False。
a = {'a', 'c'}
b = {'a', 'c', 'z', 'l', 'm'}
print(a.issubset(b)) # True
- s1.issuperset(s2)
判断集合 s2 的所有元素是否都包含在集合 s1 中,如果是则返回 True,否则返回 False。
a = {'a', 'c'}
b = {'a', 'c', 'z', 'l', 'm'}
print(a.issubset(b)) # False