Python变量

是什么

变量。顾名思义，他是可变的，是不固定的

x = 1，y = 5 + x ，求y的值

我们小学五年级第一次接触解方程，也是我们第一次认识到变量这个东西，上面这道题中的x和y都叫做变量

能做什么

变量在编程领域是必不可少的，可以说，没有变量就不存在编程，他让值有了归宿。

变量能被赋值

job = "运维"

这个job就是一个变量，我们把"运维"这两个字赋值给了job

name = "@大白鹅"

同理name也是变量，把"@大白鹅"这个字符串赋值给了name

print("我是" + job + name)

让我们组合起来感受以下变量的用法

变量能被删除引用

可以使用del删除对象的引用（并不是删除变量）

变量有多种类型

Python中有六种标准数据类型

• Number（数值）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（元组）
• Dictionary（字典）

我们来分别举例介绍

---

1. 数值

Python3支持4种数类型

• int（整数）
• float （浮点数）
• bool（布尔）
• complex （复数）

应用：

查看数值类型我们经常会用type()

age = 99
type(age)
输出：<class 'int'>

a, b, c, d = 20, 5.5123, True, 4+3j
print(type(a), type(b), type(c), type(d))
输出：<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

对于数值类型的判断，我们经常会用到isinstance ()

a = 789
isinstance(a, int)
输出：True

拓展：

在Python3中，bool是int的子类，True和False可以和数字相加

issubclass(bool, int)
输出：True
True == 1
输出：True
False == 0
输出：True
True + 1
输出：2
False + 1
输出：1

---

2. 字符串

Python中的字符串是不可变的序列数据类型，他是用单引号、双引号或三引号括起来的Unicode 字符序列。

'华为云'
"华为云鲲鹏论坛"
'''有许多知识可以在这里学到'''

应用：

获取从位置 2 到位置 5（不包括）的字符：

a = "Hello,BigWhiteGoose!"
print(a[2:5])
输出：llo

获取从开头到位置 5（不包括）的字符：

a = "Hello,BigWhiteGoose!"
print(a[:5])
输出：Hello

切到末尾

a = "Hello,BigWhiteGoose!"
print(a[6:])
输出：BigWhiteGoose!

负索引

a = "Hello,BigWhiteGoose!"
print(a[-6:-4])
输出：Go

转为大写

a = "Hello, World!"
print(a.upper())
输出：HELLO, WORLD!

转为小写

a = "Hello, World!"
print(a.lower())
输出：hello, world!

去除开头和末尾的空格

a = "    Hello, Word!    "
print(a.strip())
输出：Hello, World!

替换字符串

a = "Hello, World!"
print(a.replace("H", "J"))
输出：Jello, World!

拆分字符串

a = "Hello, World!"
print(a.split(","))
输出：['Hello', ' World!']

连接字符串

a = "Hello"
b = "World"
c = a + ' ' + b
print(c)
输出：Hello World

转义字符

若要在双引号中使用双引号，或者单引号，需要使用\进行转义

a = "Hello,\"W\"ord"
print(a)
输出：Hello,"W"ord

查看字符串长度：len()

a = "Hello,BigWhiteGoose!"
b = len(a)
print(b)
输出：20

---

3. 列表

列表本身是一个变量，可以存储多个项，列表是可以被修改的，我们可以在创建列表后对列表中的数据进行增删改查

创建列表：

nameList = ["小明","小红","小华"]
print(nameList)
输出：['小明', '小红', '小华']

也可以通过列表构造函数创建：

thislist = list(("1", "banana", "3"))
print(thislist)
输出：['1', 'banana', '3']

列表里的项是有序的，允许有重复的值，允许存储不同类型的数据

List1 = [2,"123",2,True]
List2 = [2,False,List1]
print(List2)
输出：[2, False, [2, '123', 2, True]]

应用：

列表的访问

列表的索引访问是从0开始的，第一个位置的数据对应的位置编号是0

nameList = ["小明","小红","小华"]
print(nameList[0])
输出：小明

List1 = [2,"123",2,True]
List2 = [2,False,List1]
print(List2[2][1])
输出：123

列表的负索引访问 -1 指最后一项

nameList = ["小明","小红","小华"]
print(nameList[-1])
输出：小华

列表的范围索引访问可以通过指定范围获取新列表

numList = [1,2,3,4,5,6]
print(numList[2:5])
输出：[3, 4, 5]

列表的范围负索引访问

numList = [1,2,3,4,5,6]
print(numList[-5:-2])
输出：[2, 3, 4]

从头访问到指定位置

numList = [1,2,3,4,5,6]
print(numList[:4])
输出：[1, 2, 3, 4]

从指定位置访问到末尾

numList = [1,2,3,4,5,6]
print(numList[3:])
输出：[4, 5, 6]

更改列表中的项的值

thisList = ["1", "2", "3"]
thisList[1] = "9"
print(thisList)
输出：['1', '9', '3']

同理，可以范围索引修改、范围负索引修改、开头改到指定位置，指定位置改到末尾，不再举例

向列表中添加项

添加到列表的末尾：append()

thisList = ["1", "2", "3"]
thisList.append("4")
print(thisList)
输出：['1', '2', '3', '4']

在指定索引处插入项目：insert()

thisList = ["1", "2", "3"]
thisList.insert(1, "9999")
print(thisList)
输出：['1', '9999', '2', '3']

将一个列表中的数据追加到另一个列表：extend()

list1 = [1,2,3]
list2 = ["4","5","6"]
list1.extend(list2)
print(list1)
输出：[1, 2, 3, '4', '5', '6']

extend()方法不止可以使两个列表合并，只要是可以迭代的对象，都可以使用extend(),例如字符串，数值，元组，集合，字典

删除列表中指定项

删除指定项：remove()

list1 = [1,2,3]
list1.remove(2)
print(list1)
输出：[1, 3]

删除指定索引项：pop()

list1 = [1,2,3]
list1.pop(1)
print(list1)
输出：[1, 3]

如果不指定索引，将会删除列表最后一项

list1 = [1,2,3]
list1.pop()
print(list1)
输出：[1, 2]

与pop()相似的方法是del

删除第一项

list1 = [1,2,3]
del list1[1]
print(list1)
输出：[1, 3]

你甚至可以把整个列表删了(其实是把变量引用给删除了)

list1 = [1,2,3]
del list1
print(list1)

输出：Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list1' is not defined

比del稍微温柔点的是：clear()

只清空列表，但是列表仍然存在，只是没有内容了

list1 = [1,2,3,4]
list1.clear()
print(list1)
输出：[]

列表的长度：len()

list1 = [1,2,3,4]
b = len(list1)
print(b)
输出：4

---

4. 元组

元组和列表有很多相似之处，比如他们都是有序的，允许有重复值，可存储任意数据类型的集合。

tuple1 = (1,2,3,4)
print(tuple1[2])
输出：3

也可以通过元组构造函数创建元组：

thistuple = tuple(("apple", "banana", "cherry"))
print(thistuple)
输出：('apple', 'banana', 'cherry')

但是元组是不可更改的，一个元组一旦创建出来，你就无法再对他进行添加和删除操作。

tuple1 = (1,2,3,4)
del tuple1[2]
输出：Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

虽然元组是不能更改的，但是可以先把元组转化成列表，对其修改后再转化回元组

a = (1,2,3,4)
b = list(a)
b[1] = "二"
a = tuple(b)
print(a)
输出：(1, '二', 3, 4)

同理，可以用这个中转的方法对元组实现增加，删除

---

5. 字典

字典将数据以键值对的形式保存在**{}**中，所谓键值对就是key: value

先举例子

xiaoming = {"姓名": "小明","性别": "男", "年龄": "18"}

“姓名”: “小明” 这就是其中的一个键值对，"姓名"是键(Key)，"小明"是值(Value)

你可以把这个字典变得好看一些

xiaoming = {
    "姓名": "小明",
    "性别": "男", 
    "年龄": "18"
}

输出小明的年龄的值：

xiaoming = {
    "姓名": "小明",
    "性别": "男", 
    "年龄": "18"
}
print(xiaoming["年龄"])
输出：18

字典也是有序的，可更改的，但是他不允许有重复的键存在

重复值将覆盖现有值：

xiaoming = {
    "姓名": "小明",
    "性别": "男", 
    "年龄": "18"
}
print(xiaoming)
输出：{'姓名': '小明', '性别': '男', '年龄': '20'}

字典中的项的值可以是任何数据类型

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}

应用：

访问字典

查询小明的年龄的值：

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
print(xiaoming["年龄"])
输出：18

另一种获取值的方法：get()

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
print(xiaoming.get("年龄"))
输出：18

获取键列表：keys()

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
print(xiaoming.keys())
输出：dict_keys(['姓名', '年龄', '今日课程', '是否请假'])

获取值列表：values()

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
print(xiaoming.values())
输出：dict_values(['小明', 18, ['政治课', '高数课', '地理课'], False])

获取字典中的所有键值对，以列表包含元组的形式返回：items()

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
print(xiaoming.items())
输出：dict_items([('姓名', '小明'), ('年龄', 18), ('今日课程', ['政治课', '高数课', '地理课']), ('是否请假', False)])

向字典中新增数据

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
xiaoming["考试得分"] = 150
print(xiaoming)
输出：{'姓名': '小明', '年龄': 18, '今日课程': ['政治课', '高数课', '地理课'], '是否请假': False, '考试得分': 150}

更新字典：update()

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
xiaoming.update({"年龄": 21})
print(xiaoming)
输出：{'姓名': '小明', '年龄': 21, '今日课程': ['政治课', '高数课', '地理课'], '是否请假': False}

如果更新内容是字典中本没有的，则为添加操作

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
xiaoming.update({"班级": 201})
print(xiaoming)
输出：{'姓名': '小明', '年龄': 18, '今日课程': ['政治课', '高数课', '地理课'], '是否请假': False, '班级': 201}

删除字典中的项目：pop()

pop用于删除指定键名的项

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
xiaoming.pop("是否请假")
print(xiaoming)
输出：{'姓名': '小明', '年龄': 18, '今日课程': ['政治课', '高数课', '地理课']}

删除字典中的最后一项：popitem()

这个方法在3.7版本之前的作用是随机删除一项

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
xiaoming.popitem()
print(xiaoming)
输出：{'姓名': '小明', '年龄': 18, '今日课程': ['政治课', '高数课', '地理课']}

删除指定键名的项：del（效果和pop类似，不过del无返回值）

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
del xiaoming["姓名"]
print(xiaoming)
输出：{'年龄': 18, '今日课程': ['政治课', '高数课', '地理课'], '是否请假': False}

同样，del也可以把整个字典删除了

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
del xiaoming
print(xiaoming)
输出：Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'xiaoming' is not defined

和列表，元组类似，字典也有clear()这个方法，用于清空其内容

xiaoming = {
    "姓名": "小明",
    "年龄": 18,
    "今日课程": ["政治课", "高数课", "地理课"],
    "是否请假": False
}
xiaoming.clear()
print(xiaoming)
输出：{}