python 变量以及变量的类型

最新推荐文章于 2023-03-03 18:30:19 发布

来杯卡布奇洛

最新推荐文章于 2023-03-03 18:30:19 发布

阅读量1.2k

点赞数 1

分类专栏： Python 文章标签： python 变量数据类型

本文链接：https://blog.csdn.net/lan123456_/article/details/108379191

版权

Python 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

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

变量的名称
变量保存的数据
变量存储数据的类型
变量的地址（标识）

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

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
```

来杯卡布奇洛

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
python 变量以及变量的类型

python标准数据类型变量的概念变量的赋值变量的类型Number（数字）类型变量的概念在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。在 Python 中，变量不需要声明，但是在使用前必须赋值，变量赋值以后该变量才会被创建。变量定义之后，后续就可以直接使用了。变量的赋值等号（=）用来给变量赋值。= 左边是一个变量名。= 右边是存储在变量中的值。单个变量赋值age = 18 # 整型变量money
复制链接

扫一扫