python 变量以及变量的类型

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 在内存中创建一个变量，会包括

1. 变量的名称

2. 变量保存的数据

3. 变量存储数据的类型

4. 变量的地址（标识）

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（浮点型）

$$浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示，1.2e3=1.2\ast 10^3。$$

# 科学计数法表示浮点数
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 格式化字符串

参考这篇文章：https://blog.csdn.net/lan123456_/article/details/108461098

5.4 Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

5.5 python 的字符串内建函数

参考这篇文章：https://blog.csdn.net/lan123456_/article/details/108482703

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 列表常用函数和方法

参考这篇文章：https://blog.csdn.net/lan123456_/article/details/108792614

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 字典常用函数和方法

参考这篇文章：https://blog.csdn.net/lan123456_/article/details/108831130

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 集合添加元素

1. 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'
   

2. 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 集合删除元素

1. s.remove(x)

   将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

   s = set([1, 2, 3])
   
   s.remove(1)  # {2, 3}
   s.remove(4)  # 报错，KeyError: 4
   

2. s.discard(x)

   将元素 x 从集合 s 中移除，如果元素不存在，不会发生错误。

   s = set([1, 2, 3])
   
   s.discard(1)  # {2, 3}
   s.discard(4)  # {1, 2, 3}，不会报错
   

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