Python基础入门学习笔记

一、 print()函数与变量

print()函数

前提：全部用英文输入法输入！！！！！

print(): 括号里加''，也可用双引号“”,输出字符串，如print(‘1+1’)输出1+1,print(1+1)输出2，print('我')输出我

转义字符

print()：括号内容包含''时，需区分，可用“”，或\'

print(): 括号内容需分行时，用三引号''' '''，或\n（下一句开头）

变量和赋值

赋值时需命名，用一个词如name

赋值用=，直接相等用==：如name='小花'，print（name）就是小花

总结

二、数据类型与转换

数据类型

最常用的三种数据类型：字符串(str)、整数(int)、浮点数(float)

字符串(str)

只要是被【单/双/三引号】这层皮括起来的内容，不论那个内容是中文、英文、数字，只要是被括起来的，就表示是字符串类型

字符串类型必须有引号的辅助！！！！！

整数(int)

整数可以不穿名为引号的马甲，直接跟print()函数组团搞输出

由于没有引号的保护，整数只能单独行动，即只能print(6),而不能print(6小)

也可直接运算：如print(1+1+1),输出为3

浮点数(float)

带小数点的数，如3.1415926

小结

数据连接

数据拼接符号+，将需要拼接的变量连在一起即可

type()函数

帮助我们查询不确定数据的类型

数据转换

负责转换数据类型的函数一共有3种：str()、int()、float()

str()函数

str():能将数据转换成其字符串类型，借用引号''也可将整数转换字符串类型，如number=10,print(str(number))输出10，或print('10')输出10

int()函数

int():将数据转换为整数类型，如print(int(2.6))得到2，只有符合整数规范的字符串类数据，才能被int()强制转换，如print(int('2.6'))就不行，不需要''

对于浮点数，int()函数会做取整处理。int()函数会直接抹零，直接输出整数部分

float()函数

float():将整数和字符串转换为浮点类型。如果括号里面的数据是字符串类型，那这个数据必须是数字形式。将数字转换为浮点数字符串，name=2.6,float(name)

字符串拼接

字符串拼接+，print()函数：如print(sentence+str(int(float(word)+number)))

小结

总结

三、条件判断与条件嵌套

条件判断

在什么条件下，该去做什么

单向判断：if

如number=3,if number>=2：,print('棒')，：符号后enter会使print()下行缩进，成为了if条件下的内部命令，表示print()从属执行于if,无缩进则会出现错误！

双向判断：if…else…

（1）if和else两个条件判断是平级关系；（2）当if条件不被满足时，才会执行else下的命令

注意if和else不缩进，else后面也要跟冒号!

多向判断：if…elif…else…

如果if的条件不满足，按顺序看是否满足elif的条件，如果不满足elif的条件，就执行else的命令

当判断的条件超过3个时，中间的多个条件都可以使用elif

if、elif、else是平级关系，后面都跟冒号且不缩进

if嵌套

elif也是可以放进嵌套里的，就是在上述结构的基础上，多加一个带头大哥elif条件，以及底下跟着的elif条件的小弟就好

当多个条件存在时，else不是必须的，可以if…elif…elif

如何写嵌套代码

扒洋葱法，理清逻辑

总结

四、 input()函数

input()函数

input()函数的使用

input()函数是输入函数，当你在函数的括号内写出问题时，input()函数会将此问题原样显示在屏幕上，并在终端区域等待你针对此问题的回答。需要回答内容！

input()函数结果的赋值

必须赋值！对input()函数的结果进行赋值，然后使用input()函数搜集信息，最后再用print()函数输出结果,如name=input('电影名字：')，print(name+'是好电影')

input()函数的数据类型

input()函数的输入值（搜集到的回答），永远会被强制性地转换为字符串类型

赋值时一定要是字符串！！！

input()函数结果的强制转换

用int()强制转换字符串为整数，如choice = int(input('请输入您的选择：'))

小结

五、列表和字典

列表

什么是列表

一个列表需要用中括号[ ]把里面的各种数据框起来，里面的每一个数据叫作“元素”。每个元素之间都要用英文逗号隔开，如['小明','小红','小刚']

列表很包容，各种类型的数据（整数/浮点数/字符串）无所不能包!

从列表提取单个元素

1.偏移量是从0开始的，而非我们习惯的从1开始；

2.列表名后加带偏移量的中括号，就能取到相应位置的元素

如students = ['小明','小红','小刚']

print(students[0])

从列表提取多个元素

list2 = [5,6,7,8,9]

print(list2[:]) 所有

print(list2[2:]) 第2位开始到后面所有

print(list2[:2]) 第（2-1）位及前面所有

print(list2[1:3]) 第1位及到第（3-1）位的所有

print(list2[2:4]) 第2位及到第（4-1）位的所有

[5, 6, 7, 8, 9]

[7, 8, 9]

[5, 6]

[6, 7]

[7, 8]

给列表增加/删除元素

增加用append():如lists=[2,3,4,],lists.append(5),print(lists);

如lists=['小红','小美'],lists.append('小花'),print(lists)

字符串需加''，数字不用

删除用del函数：如students = ['小明','小红','小刚','小美']

del students[1]

print(students)

即删除了小红

小结

数据类型：字典（dictionary）

什么是字典

字典的外层是大括号{ }

字典的元素是由一个个键值对构成的，用英文冒号连接。如'小明':95，其中我们把'小明'叫键（key），95叫值(value)

字典中的键具备唯一性，而值可重复

**可以用len()函数来得出一个列表或者字典的长度（元素个数），括号里放列表或字典名称

从字典中提取元素

scores = {'小明': 95, '小红': 90, '小刚': 90}

print(scores['小明'])

给字典增加/删除元素

删除字典里键值对的代码是del语句del 字典名[键]，

而新增键值对要用到赋值语句字典名[键] = 值

album = {'周杰伦':'七里香','王力宏':'心中的日月'}

del album['周杰伦']

print(album)

#删除

album['周杰伦'] = '十一月的萧邦'

print(album)

print(album['周杰伦'])

#新增（修改分数也一样，=新值就可以了）

{'王力宏': '心中的日月'}

{'王力宏': '心中的日月', '周杰伦': '十一月的萧邦'}

十一月的萧邦

小结

列表和字典的异同

列表和字典的不同点

列表中的元素是有自己明确的“位置”的，所以即使看似相同的元素，只要在列表所处的位置不同，它们就是两个不同的列表,

而字典相比起来就显得随和很多，调动顺序也不影响。因为列表中的数据是有序排列的，而字典中的数据是随机排列的。

列表有序，要用偏移量定位；字典无序，便通过唯一的键来取值

列表和字典的相同点

1.在列表和字典中，如果要修改元素，都可用赋值语句来完成

如果只需要修改键里面的值，可不需要del语句，del语句通常是用来删除确定不需要的键值对

2.支持任意嵌套。列表可嵌套其他列表和字典，字典也可嵌套其他字典和列表。

列表：

提取小芳即 print(students[1][3])

字典：

scores = { '第一组':{'小明':95,'小红':90,'小刚':100,'小美':85}, '第二组':{'小强':99,'小兰':89,'小伟':93,'小芳':88} }

print(scores['第二组']['小芳'])

拓展：元组（tuple）

可以看到：元组和表格很相似，不过，它是用小括号来包的。

元组和列表都是序列,提取的方式也是偏移量，如 tuple1[1]、tuple1[1:]。另外，元组也支持任意的嵌套。

tuple1 = ('A','B')

六、 for循环和while循环

for...in...循环语句

不要忘记！！！！！

for循环：空房间

空房间的学名叫【元素】（item）

如列表

for i in [1,2,3,4,5]:

#i是“空房间”

print(i)

#得到12345

for循环：一群排队办业务的人

如字典

dict = {'日本':'东京','英国':'伦敦','法国':'巴黎'}

for i in dict:

print(i)

#得到键

日本

英国

法国

！！！整数、浮点数是不属于“一群排队办业务的人”的，如果把它们放在for循环里，代码会报错

！！！列表，字典，字符串都可以是“一群排队办业务的人”

range()函数

！！！使用range(x)函数，就可以生成一个从0到x-1的整数序列

如

for i in range(3):

print(i)

#会得到0，1，2

！！！使用range(a,b) 函数，你可以生成了一个【取头不取尾】的整数序列

如

for i in range(13,17):

print(i)

#会得到13，14，15，16

！！！当你想把一段代码固定重复n次时，就可以直接使用for i in range(n)解决

如

for i in range(3):

print('我很棒')

#会输出3遍我很棒

！！！range(0,10,3)的意思是：从0数到9（取头不取尾），数数的间隔为3，即输出位0，3，6，9

for循环：办事流程

d = {'小明':'醋','小红':'油','小白':'盐','小张':'米'}

for i in d:

print(d[i])

#输出醋

油

盐

米

while循环

#输出为1，2，3，4，5，

“在一定的条件下”，“按照流程办事”

while循环：放行条件

while循环：办事流程

！！！有缩进的时候，print(a)也是循环中的“办事流程”，会将数字逐一打印！！！

！！！没有缩进的时候，循环中的“办事流程”就只有做加法，print(a)也就只会打印循环结束时的最后一个数字！！！

两种循环对比

for循环和whlie循环最大的区别在于【循环的工作量是否确定】:

for循环就像空房间依次办理业务，直到把【所有工作做完】才下班。

while循环就像哨卡放行，【满足条件就一直工作】，直到不满足条件就关闭哨卡。

所以说，当我们【工作量确定】的时候，我们就可以让for循环来完成重复性工作。

反之，要【工作量不确定时】可以让while循环来工作。

students = ['小明','小红','小刚']

for i in range(3):

student1 = students[0] # 获取第一个座位的学生 student1

students = students[1:] # 让 student1 暂时离开，后面的学生座位都进一位。

students.append(student1) # 将 student1 安排到最后一个座位

print(students)

#三人轮流坐第一位

pop()函数

pop()函数，用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

可以将其理解为提取和删除的融合：①提取：取到元素，对列表没有影响；②删除：删除列表的元素。

而移除，则是同时做到取到元素，并且删除列表中的元素。

students = ['小明','小红','小刚']

print(students.pop(1))

#是删除了小红，pop()里用数字，不能用字符串

print(students)

七、布尔值和四种语句

用数据做判断：布尔值

计算机的逻辑判断，只有两种结果，就是True（英文意思是“真”）和False（英文意思是“假”），没有灰色地带。这个计算真假的过程，叫做【布尔运算】

True和False，也就叫做【布尔值】

只有当条件判断为True时，if和while后面的子句才会执行下去。

如

while False:

print('while False')

#执行后没有循环，循环结束

#因为while循环执行，必须要while后的条件为“真”，而【布尔值】False本身就是“假”，所以这个循环一次都没运行就结束了

如

if False:

print('if False')

if True:

print('if True')

#只有if True成功运行，将结果显示在了屏幕上。当然，if语句不会陷入死循环！！！

布尔运算的三种方式

两个数值做比较

如print(3>5)，计算机会先做一次布尔运算，判断3是否大于5，然后再把判断的结果以【布尔值】的方式打印出来

直接用数值做运算

if 1:

print('熊猫')

#会输出熊猫

整数1在这里就是作为一个条件，被判断为真（True）。这就是数值本身作为一个条件，被判断真假的情况，因为在Python中已经设定好什么数据为真，什么为假。假的是有限的，那么除了假的，就都是真的

None，它代表的是【空值】，自成一派，数据类型是NoneType。要注意它和0的区别，0是整数0，可并非什么都没有。

可以使用bool()函数来查看一个数据会被判断为真还是假。这个函数的用法与type()函数相似，在bool()函数括号中放入我们想要判断真假的数据，然后print出来即可

布尔值之间的运算

and、or、not、in、not in五种运算

1.and

2.or

3.not True就等于False，not False就等于True

4.【in】的意思是“判断一个元素是否在一堆数据之中”，【not in】反之

如

list = [1,2,3,4,5]

a = 1

print(bool(a in list))

print(bool(a not in list))

#判断是否在列表里，使用bool()函数来查看一个数据会被判断为真还是假

#True

False

如果涉及到的数据集合是字典的话，【in】和【not in】就可以用来判断字典中是否存在某个【键】

小结

四种新的语句

break语句

break的意思是“打破”，是用来结束循环的，一般写作if...break

# break语句搭配for循环

for...in...:

...

if ...:

break

***if...break的意思是如果满足了某一个条件，就提前结束循环。记住，这个只能在循环内部使用

# break语句搭配while循环

while...(条件):

...

if ...:

break

！！！break前面一共缩进了【8个空格】

【注】：Tab键和空格键不能同时混用

！！！while True这个条件恒为真，就会开启无限循环。而while True常和break语句搭配使用

用while True 开启了一个无限循环。你也可以用while 1 或其他形式开启一个无限循环

continue语句

continue的意思是“继续”。这个子句也是在循环内部使用的。当某个条件被满足的时候，触发continue语句，将跳过之后的代码，直接回到循环的开始。

# continue语句搭配for循环

for...in...:

...

if ...:

continue

...

# continue语句搭配while循环

while...(条件):

...

if ...:

continue

...

continue的作用就是就是当某个条件为真时，又提前回到循环，而不会执行下面的代码！！！

pass语句

英文意思是“跳过”

a = int(input('请输入一个整数:'))

if a >= 100:

pass

else:

print('你输入了一个小于100的数字')

#输入101的话直接运行显示没有内容，但运行通过

else语句

else不但可以和if配合使用，它还能跟for循环和while循环配合使用

跟逻辑判断一样的用法

小结

习题1：囚徒困境

两人都认罪，则各判10年；一个认罪一个抵赖，则前者判1年，后者判20年；两人都抵赖，各判3年。只有两人都不认罪，程序才会停止。

现在有一个社会学家，在不同的人群中做这个实验，一旦遇到都不认罪的情况，就停止该人群中的实验。

同时，他希望程序能记录每一对实验者的选择，以及记录第几对实验者都选择不认罪。

n = 0

list_answer = []

#定义一个列表

while True:

n =n+ 1

#也可用n+=1

a = input('A，你认罪吗？请回答认罪或者不认：')

b = input('B，你认罪吗？请回答认罪或者不认：')

list_answer.append([a,b])

# 用列表嵌套的方式来存放实验者的选择，也可用元组或字典。每一次回答，列表会多一个元素【a,b】

if a == '认罪' and b == '认罪':

print('两人都得判10年，唉')

elif a == '不认' and b == '认罪':

print('A判20年，B判1年，唉')

elif a == '认罪' and b == '不认':

print('A判1年，B判20年')

else:

print('都判3年，太棒了')

break

#break停止循环后默认为得到最优的解了

print('第' + str(n) + '对实验者选了最优解。')

for i in range(n):

# 注意数据类型的转换，以及计数起点的不同（0和1），range(n)是从0开始

print('第' + str(i+1) + '对实验者的选择是：' + str(list_answer[i]))

#输出前面储存的回答，比如循环了3次，则输出第1次的数据就是i=0时的回答[a,b]

习题2：输入演员查电影名

让其他人只要输入演员名，就打印出：××出演了电影××。

movies = {

'妖猫传':['黄轩','染谷将太'],

'无问西东':['章子怡','王力宏','祖峰'],

'超时空同居':['雷佳音','佟丽娅'],

}

actor = input('你想查询哪个演员？')

for movie in movies:

# 用 for 遍历字典，for...in...是遍历了电影名（即遍历的是【键】）

actors = movies[movie]

# 读取各个字典的主演表，字典提取【值】时是用:字典名[键]，输出就是值，如print(scores('小明'))得到的是90分。

if actor in actors:

print(actor + '出演了电影' + movie)

八、项目实操：PK小游戏（1）

明确项目目标

分析过程，拆解项目

逐步执行，代码实现

版本1.0：自定属性，人工PK

1.规定并显示出玩家和敌人的属性 2.双方同时互相攻击，血量根据对方的攻击力扣除 3.若有一方血量小于等于0，游戏结束。

为了让打印出的东西能有时间间隔地依次出现，我们需要设置一个类似“计时器”的东西。在Python里，我们需要用到两行代码来实现：

版本2.0：随机属性，自动PK：random模块里的randint()函数

要随机生成整数，就要用到random模块里的randint()函数，括号里放的是两个整数，划定随机生成整数的范围。

#可以多运行几次，看看结果是不是随机生成的~

import random

#调用random模块，与

a = random.randint(1,100)

# 随机生成1-100范围内（含1和100）的一个整数，并赋值给变量a

print(a)

！标准的变量名最好是用英文来表达含义，如果是多个单词组成，需要用英文下划线_来隔开。推荐大家一个网站:CODELF，输入中文就可以看到别人是怎么命名的。

用 while 循环实现自动攻击

版本3.0：打印战果，三局两胜

三局战斗也是一个可以循环的结构，且循环次数是固定的，所以要用到for循环

import time

import random

player_victory = 0

enemy_victory = 0

for i in range(1,4):

time.sleep(1.5)

print(' \n——————现在是第 %s 局——————' % i)

#对比之前：(' \n——————现在是第'+str(i)+'局——————')

player_life = random.randint(100,150)

player_attack = random.randint(30,50)

enemy_life = random.randint(100,150)

enemy_attack = random.randint(30,50)

print('【玩家】\n血量：%s\n攻击：%s' % (player_life,player_attack))

print('------------------------')

time.sleep(1)

print('【敌人】\n血量：%s\n攻击：%s' % (enemy_life,enemy_attack))

print('-----------------------')

time.sleep(1)

while player_life > 0 and enemy_life > 0:

player_life = player_life - enemy_attack

enemy_life = enemy_life - player_attack

print('你发起了攻击，【敌人】剩余血量%s' % enemy_life)

print('敌人向你发起了攻击，【玩家】的血量剩余%s' % player_life)

print('-----------------------')

time.sleep(1.2)

if player_life > 0 and enemy_life <= 0:

player_victory += 1

print('敌人死翘翘了，你赢了！')

elif player_life <= 0 and enemy_life > 0:

enemy_victory += 1

print('悲催，敌人把你干掉了！')

else:

print('哎呀，你和敌人同归于尽了！')

if player_victory > enemy_victory :

time.sleep(1)

print('\n【最终结果：你赢了！】')

elif enemy_victory > player_victory:

print('\n【最终结果：你输了！】')

else:

print('\n【最终结果：平局！】')

【格式化字符串】

为了更方便地实现不同数据类型的拼接，用【格式符%】是更常用更便利的一种方式

格式符%后面有一个字母s，这是一个类型码，用来控制数据显示的类型。%s就表示先占一个字符串类型的位置

%后面的类型码用什么，取决于你希望这个%占住的这个位置的数据以什么类型展示出来，如果你希望它以字符串形式展示，那就写%s，如果你希望它以整数形式展示，那就写%d。

如

lucky = 8

print('我的幸运数字是%d' % lucky)

print('我的幸运数字是%d' % 8)

print('我的幸运数字是%s' % '小龙女的生日816')

print('我的幸运数字是%d和%d' % (8,16))

我的幸运数字是8

我的幸运数字是小龙女的生日816

我的幸运数字是8和16

新的“格式化字符串”的方法：format()函数

# % 格式化：str % ()

print('%s%d'%('数字：',0))

print('%d，%d'%(0,1))

print('%d，%d，%d'%(0,1,0))

name1 = 'Python'

print('I am learning %s'% name1)

# 注：当只跟一个数据时，%后可不加括号，format()一定要有。

# format()格式化函数：str.format()

print('\n{}{}'.format('数字：',0))

# 优势1：不用担心用错类型码。

print('{}，{}'.format(0,1))

# 不设置指定位置时，默认按顺序对应。

print('{1}，{0}'.format(0,1))

# 优势2：当设置指定位置时，按指定的对应。

print('{0}，{1}，{0}'.format(0,1))

# 优势3：可多次调用format后的数据。

name2 = 'Python基础语法'

print('我正在学{}'.format(name2))

# format()函数也接受通过参数传入数据。

输出为：

九、编程思维：如何解决问题

瓶颈1：知识学完就忘

用法查询笔记

【用法查询笔记】就是记录知识点的基础用法，它是你的学习记录，能供你快速查阅，加深对知识的印象。

要记住的是：不管你用什么格式记笔记，目的只有一个，就是 “方便自己查询使用”。

如

深度理解笔记

【深度理解笔记】重在“理解”，所以笔记内容主要是记录对知识的理解。

知识管理

在解决一个编程问题的时候，我们可以轻易想到需要用到哪块知识，接着就可以去【用法查询笔记】里寻找相关的知识细节和具体案例，形成解题的思路。

瓶颈2：缺乏解题能力

如何解题

打印九九乘法表：

for i in range(1,3):

print('%d X %d = %d' % (i,2,i*2),end = ' ')

print('') #用来换行

for i in range(1,4):

print('%d X %d = %d' % (i,3,i*3),end = ' ')

print('') #用来换行

输出为：

1 X 2 = 2 2 X 2 = 4

1 X 3 = 3 2 X 3 = 6 3 X 3 = 9

总表：

for i in range(1,10):

for j in range(1,i+1):

#i=1时，j的范围是1

print( '%d X %d = %d' % (j,i,i*j),end = ' ' )

print(' ')

列表排序：sort(reverse=True/False)

list3= [91, 95, 97, 99, 92, 93, 96, 98]

list3.sort(reverse=False)

#升序（从大到小）用 list3.sort(reverse=True))

print(list3)

#[91, 92, 93, 95, 96, 97, 98, 99]

或：

list1 = [91, 95, 97, 99]

list2 = [92, 93, 96, 98]

# 把 A 组成绩赋值给一个新列表，用来存合并的成绩——这个细节要注意！

list3 =list1

list3.extend(list2)

print(list3)

list3.sort()

print(list3)

详情：

import numpy as np # 导入 numpy库，下面出现的 np 即 numpy库

scores1 = [91, 95, 97, 99, 92, 93, 96, 98]

scores2 = []

average = np.mean(scores1) # 一行解决。

print('平均成绩是：{}'.format(average))

for score in scores1:

if score < average:

scores2.append(score)

continue # 少于平均分的成绩放到新建的空列表中，然后继续判断。

print(' 低于平均成绩的有：{}'.format(scores2)) # 上个关卡选做题的知识。

# 下面展示一种NumPy数组的操作，感兴趣的同学可以自行去学习哈。

scores3 = np.array(scores1)

print(' 低于平均成绩的有：{}'.format(scores3[scores3<average]))

十、函数

函数是什么

括号里放的东西，也就是我们需要输入的数据，它在函数中被称作【参数】。【参数】指向的是函数要接收、处理怎样的数据。

定义和调用函数

定义函数

第1行：def的意思是定义(define)，greet是【函数名】（自己取的），再搭配一个括号和冒号，括号里面的name是参数（参数名也是自己取）。

第2行：def下一行开始缩进的代码是函数要实现的功能，也叫【函数体】。这里的函数体展现出的功能就是：打印出“name+ 早上好”这句话。

第3行：一个简单的return。函数内部一旦遇到return语句，就会停止执行并返回结果。没有return语句的函数，Python也会在末尾隐性地加上return None，即返回None值（return None可以简写为return。）所以你也会看到，我们接下来的很多例子是省略了return语句的。

！！！定义函数只是将函数的内部功能封装起来（组织好），运行不会输出任何内容！！！

调用函数

怎么调用函数呢？在Python里，就是输入函数名和参数对应的值：

def pika2(name):

print('我最喜爱的神奇宝贝是'+name)

pika2('皮卡丘') #调用函数，输入函数名pika()并输入参数'皮卡丘'

pika2('喷火龙') #调用函数，输入函数名pika()并输入参数'喷火龙'

函数重要概念

参数类型

主要的参数类型有：位置参数、默认参数、不定长参数。

【位置参数、默认参数】

参数可以替换！

【不定长参数】

不限定死数量，这时候【不定长参数】就能派上用场，即不确定传递参数的数量。

它的格式比较特殊，是一个星号*加上参数名

('烤鸡翅', '烤茄子', '烤玉米')，这种数据类型叫做元组(tuple)

元组的写法是把数据放在小括号()中，它的用法和列表用法类似，主要区别在于列表中的元素可以随时修改，但元组中的元素不可更改。

！！！默认参数也需要放在不定长参数的后面，即dessert=’绿豆沙'要放在*barbeque后面，否则传递的值会对应不上！！！

return语句

如：

最终输出是“嗯，人生才刚刚开始”

main()函数内部分别调用了face()和body()函数，参数dream_face和dream_body传递给了face()和body()函数的参数name，得到返回值，并打印

前面所有的return语句，都是返回1个值，如果要返回多个值

Python语言中的函数返回值可以是多个，而其他语言都不行，这是Python相比其他语言的简便和灵活之处。一次接受多个返回值的数据类型就是元组。

而元组与列表其实都是数据的“序列”，元组取某个位置的值的操作，与列表是一模一样的，即tuple[]

小结

变量作用域

第一点：在一个函数内定义的变量仅能在函数内部使用（局部作用域），它们被称作【局部变量】。

第二点：在所有函数之外赋值的变量，可以在程序的任何位置使用（全局作用域），它们叫【全局变量】。

！！！全局作用域中的代码中也不能使用任何局部变量！！！

当变量处于被定义的函数内时，就是局部变量，只能在这个函数内被访问；当变量处于被定义的函数外时，就是全局变量，可以在程序中的任何位置被访问。

也可以用global语句将变量声明为全局变量！！！

抽奖练习

扑克牌

# 生成扑克牌：返回一个扑克牌列表，里面有52个元组，对应52张牌。

def cards():

color = ['红心', '方块', '梅花','黑桃'] # 将花色放在一个列表中待用

num = list(range(2, 11))

num.extend('JQKA') # 通过两行代码，生成一个 2-A 的数字列表。

return [(x, y) for x in color for y in num ] # 用列表生成式完成扑克牌的生成。

print(cards())

# 注：花色对应的正式单词是：suit和rank，上面为了好理解所以用了 color。