Python学习笔记变量类型

最新推荐文章于 2024-08-01 19:45:58 发布

June·DD

最新推荐文章于 2024-08-01 19:45:58 发布

阅读量260

点赞数 2

分类专栏： Python 文章标签： Python基础变量类型

本文链接：https://blog.csdn.net/dark_cy/article/details/98479374

版权

Python 专栏收录该内容

27 篇文章 2 订阅

订阅专栏

变量

什么是变量
变量就是一个名字，它指向一个具体的值，我们可以通过这个名字访问它所指向的值。因为它可以指向不同的量，所以我们称它为变量。但是变量在同一时刻只能指向一个值。
使用注意点
①、Python的变量不需要声明类型，如变量 num 可以和整数 10 绑定，也可以和字符串"ten"绑定。
②、在给变量命名的时候需要满足以下规范：
　　 - 变量名可以由字母、数字、下划线组成，但是不能以数字开头。
　　 - 字母可以是大小写，但大小写严格区分，代表不同的含义
　　 - 在给变量命名的时候尽量做到观其名而知其义的效果（这条不是硬性的）
③、变量在使用前需要先对其进行赋值，即产生变量和值的绑定关系，使变量名指向值。之后我们才可以利用变量名进行对值的操作。
④、赋值需要满足一定的语法要求：变量名在赋值号（=）左边，值在赋值号右边。如：

num = 10 
#在内存中开辟一块空间存储数值10，并令变量num和数值10发生绑定关系，此后对num的操作即对数值10的操作
# 要注意 Num 和 num 代表不同的变量
del num
# 删除变量，解除num与值的绑定关系，有可能释放值的内存空间，
2num = 10 
#这是错误示范，原因是以数字开头

变量类型

数值（int、float、complex）
1. 数值这种类型就是用来存储数字的
2. 它可以细分为如下三种数据类型
  ①、int ：整型，包括正整数、0和负整数
  ②、float：浮点型，即含有小数的数，包括科学计数法的形式
  ③、complex：复数，如：(10 + 9j)
示例：

num_1 = 10          # num_1 为 int 型
num_2 = 10.2
num_3 = 10e2        # num_2 和 num_3 为 float 型
num_4 = (10 + 9j)   # num_4 为 complex 型

字符串（str）
1. 字符串是Python中表示文本的数据类型，它可以表示英文字符和中文字符。
2. 字符串有两种方式访问它的字符元素
  ①、从左到右，默认索引从0开始
  ②、从右到左，默认索引从-1开始，如下例：

str = "dark"
'''
元素       d   a   r   k 
下标       0   1   2   3
下标      -4  -3  -2  -1
'''
print(str)  # dark
print(str[0]) # d
print(str[-4]) # d

　　　　3. 转义字符：以"\ " 开头的字符序列，表示将"\ " 后面的字符转换成另外的含义。如"\n"表示换行。

# 示例
print("Holle\nWorld")
'''
输出结果为：
Holle
World
'''
# 那么问题来了，如果你是想把字符串"Holle\nWorld"原样输出，那怎么办呢？
#两种方法：1、在被转义的字符前面加'\'  2、在字符串前加字符 "r"
print("Holle\\nWorld") # Holle\nWorld
print(r"Holle\nWorld") # Holle\nWorld

　　　　4. 从字符串截取子串可以采用 [头下标:尾下标:步长] 的方法，如下例：

str = "ABCDEFGHIJK"
print(str[1:5:2]) #截取下标属于[1,5)的元素，步长为2的元素
# BD    步长即从头下标开始每次增加的长度，本例首先是str[1],然后是str[1+2]，因为str[1+2+2]的下标不属于[1,5)，故只输出str[1]和str[3]两个字符
print(str[1:5])   # 截取下标属于[1,5)，因为步长没有给出，所默认为1
# BCDE
print(str[1:])    # 截取下标从1开始的元素，尾下标没有给出，则默认为是最大下标
# BCDEFGHIJK
print(str[:5])    #截取下标[0,5)的元素，头下标没有给出，则默认为是0
# ABCDE
print(str[:])     #结合上面的例子不难看出这是截取整个字符串
# ABCDEFGHIJK
# 上面的例子都是从左往右截取，当然也可以从右往左截取

列表（list）
　　列表是Python的内置数据结构，是一种可迭代、可递归的有序序列。它可以同时存放数值、字符串、列表、集合、字典、元组等数据。它跟字符串一样，可以利用 [] 随机访问元素，也可以用 [头下标:尾下标:步长] 的方法截取子列表。此外列表有很多的内置方法，如append、remove、insert等。示例如下：

L1 = [1,"string",[2]]  # 创建一个非空列表
L2 = list()            # 创建一个空列表
L3 = [i for i in L1 if i!=1] # 利用生成式创建列表 L3 = ["string",[2]]
L1.append(4)           # 从尾部插入一个元素 4
L1.insert(3,"four")    # 在下标为 3 的元素前面插入一个元素 "foer"
L1.remove(1)           # 删除第一个数值为 1 的元素
print(L1)
# 输出结果：['string', [2], 'four', 4]
# 更多方法不一一列举了

　　　列表的一个坑

L1 = [1, 2, 3]
L2 = L1
L2.append(4)
print(L1)
print(L2)
# [1, 2, 3, 4]
# [1, 2, 3, 4]

　　　上面的例子，我们本只想在列表 L2 中插入一个元素，可没想到 L1 中也增加了一个元素。事实上，在上面的例子中L2和L1共同指向一个对象，即 [1，2，3]。而赋值操作只是相当于给 L1 起了一个别名。如果我们想要将一个列表对象复制到另一个对象里，有两种方法可以实现，那就是copy方法和切片。但这两种方法都只能实现浅复制，即不能复制嵌套列表。

L1 = [1, 2, 3, 4]
L2 = L1.copy()   # 利用copy方法
L3 = L1[:]       # 利用切片方法，所有序列都可以进行切片操作
L2.append(5)
L3.append(6)
print(L1)
print(L2)
print(L3)
# [1, 2, 3, 4]
# [1, 2, 3, 4, 5]
# [1, 2, 3, 4, 6]

　　　深层复制需要导入copy模块

# 例如下
import copy
L1 = [1, 2, 3, [1, 2, 3]]
L2 = copy.deepcopy(L1)
L2[3][2] += 1
print(L1)
print(L2)
# [1, 2, 3, [1, 2, 3]]
# [1, 2, 3, [1, 2, 4]]

元组（tuple）
　　元组可以看做是一种不可更改数据的列表。除了不能对元组内的元素值进行修改以外，列表所具有的的功能它基本都能实现。其实它就是个只读列表！

L1 = [1,"string",[2]]
tup1 = ()
tup2 = tuple() # tup1和tup2是创建一个空元组
tup3 = (1,)    # 创建一个只有一个元素的元组，括号可省。注：逗号不可省略，否则tup3就是个int型值为1的变量了
tup4 = (1,"dark")   # 创建一个多元素的元组，括号可省。
tup5 = tuple(L1)    # 以 L1 的元素生成一个元组
# 元组是不能对其元素进行增删改的，所以列表的有些方法元组是不能使用的，如：remove，append等

集合（set）
　　元素唯一的无序序列，它具有元素唯一、不能随机访问数据的特点。另外集合内的元素只能是可哈希数据，如string、int、float、tuple、冰冻集合（frozenset，即不能修改数据的集合）等。

s1 = set()     # 创建一个空集合
s2 = {1,2,3,4} # 创建一个非空集合
s3 = {i for i in s2 if i != 2} # 利用生成式创建集合，可以不要条件语句
# 注：不能用 s = {} 的方法创建空集合，如果{}中没有值，则创建的是一个字典(dict)，而不是集合
s1.add(2)      # 尾部插入一个元素
s2.remove(3)   # 删除指定元素，若没有该元素会报错
s4 = s2.difference(s1) # 与s4 = s2-s1相同
s1.clear()     # 清空集合

字典（dict）
　　一种无序的组合数据，以键值对的形式存储数据。形式为 key : value。其中key必须是可哈希的数据（如 int、float、complex、str、tuple），而且一个key只能对应一个value，value可以是任何值，也可以对应多个key。

d1 = {}
d2 = dict()        # d1和d2是创建空的字典
d3 = {'one' : 1, 'two' : 2, 'three' : 3} # 创建一个非空字典
d4 = dict(one = 1, two = 2, three = 3)   # 利用关键字创建一个非空字典
print(d4["one"])   # 通过关键字访问其对应的值
# 输出结果：1
for k,v in d4.items(): #利用items方法遍历字典
    print(k,":",v)
d5 = {k : v for k,v in d4.items() if v != 2} # 利用生成式创建字典
print(d5)   # 输出 ：{'one': 1, 'three': 3}
d5["four"] = 4  # 为新键赋值来插入新的键值对
print(d5)
print(d5.keys())  #返回字典的键值组成的元组
print(d5.values()) #返回字典的值组成的元组
# {'one': 1, 'three': 3, 'four': 4}
# dict_keys(['one', 'three', 'four'])
# dict_values([1, 3, 4])
# 更多方法不一一列举

注意：在 python 中，数值、字符串和元组是不可更改的对象，而列表、字典等则是可以修改的对象。

不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，而是相当于新生成了a。
可变类型：变量赋值 L=[1,2,3,4] 后再赋值 L[1]=5 则是将列表 L 的第二个元素值更改了，本身 L 没有动，只是其内部的一部分值被修改了。

函数（function）
　　之所以把函数写在这里，是因为在python中函数名也可以当做值被赋予变量来。举个栗子

def sum (num_1, num_2):   # 先写一个函数，输出和
    print(num_1 + num_2)
sum(3,4)                  # 调用sum 函数
sum_1 = sum               # 把函数名当做变量赋值给另一个变量sum_1
sum_1(3,4)                # 像调用sum函数一样调用sum_1
# 7 
# 7
# 事实上sum和sum_1是同一个函数，它们具有相同的id

Python中可以给变量赋值任何对象，而Python中一切皆为对象

Python中用type()函数和isinstance()函数来获取变量的类型信息，具体用法如下

intnum = 10
strnum = "ten"
print(type(intnum))    # 利用type函数返回变量的类型
print(isinstance(strnum,str)) # 利用isinstance函数判断变量是否是这一类型，是则返回True，否则返回False
# 输出结果：
# <class 'int'>
# True

变量作用域

　　变量的作用于分为全局变量(global)和局部变量(local)。可以简单的理解为在函数模块中定义的变量就是局部变量，在函数外定义的变量就是全局变量。

作用域规则：全局变量可以在全局范围内直接调用，局部变量只能在函数或模块内调用。
就近原则：如果有重名变量，则优先调用该函数或模块内的变量

　　我们可以利用关键词global来扩展局部变量的作用域，使之成为全局变量，如global age = 10。可以利用关键词 del 来结束变量的作用域，如del age。del 的作用就是删除变量，解除绑定关系，有可能释放空间。

谈一下为啥说有可能释放空间
　　
　　Python中，大部分数据都是在用到的时候才申请一块空间来存储它，但是对于一些常用的数据，是一直存储在内存中的。所以当 del 的变量指向这些常用的数据时，就不会释放空间。更多的，Python根据对象的引用计数来决定要不要回收一个对象。而 del 的作用是删除绑定(解除变量与对象的绑定关系)，使引用计数减一，只有当引用计数为0时，对象才会被回收，空间被释放。