Python基础笔记
一、字符串
1、字符串拼接
拼接是字符串常见的操作，可以用加号 把两个字符串连接起来，产生一个新的字符串，像这样
myFavorit = '我最爱的运动是：'
sport = '足球'
print(myFavorit + sport)
运行结果如下
我最爱的运动是：足球
当然，还可以有更多的拼接，像这样
myFavorit = '我最爱的运动有：'
sport1 = '足球'
sport2 = '蓝球'
print( myFavorit + sport1 + '---' + myFavorit + sport2 )2、字符串元素索引
大家看看这个字符串
'刘总你好啊'
大家从字符串内容就可以看出，里面有5个字符，每个字符都是这个字符串的一个元素。
字符串就是由一个个 元素 — 字符 组成的。
特别特别要注意的是，字符串元素的索引是从 0 开始，而不是从1 开始。
上面的字符串
刘 这个字符的索引是 0 ，
总 这个字符的索引是 1 ，
你 这个字符的索引是 2 ，
好 这个字符的索引是 3 ，
啊 这个字符的索引是 4 ，
Python可以用索引来获取一个字符串中的某个字符 ，对于这样的一个字符串定义
hello = '刘总你好啊'
刘 这个字符可以这样获取 hello[0] ， 运行如下代码看看
hello = '刘总你好啊'
print(hello[0])
总 这个字符可以这样获取 hello[1]，
你 这个字符可以这样获取 hello[2] ，
好 这个字符可以这样获取 hello[3] ，
啊 这个字符可以这样获取 hello[4] ，
根据这个规则，一个长度为 len 的字符串， 它的最后一个字符的下标是len-1。
如果是这样的一行代码呢？
hello = '刘总你好啊'
print(hello[5])
由于并不存在一个下标索引为5 的元素， 就会报下面这样的错误
IndexError: string index out of range
而且Python还支持 用负数表示字符串的索引 ， 最后一个字符的索引是 -1, 倒数第二个是 -2， 以此类推
所以 ，也可以说，上面的字符串
啊 这个字符的索引是 -1 ， 可以这样获取 hello[-1] ，
好 这个字符的索引是 -2 ， 可以这样获取 hello[-2] ，
你 这个字符的索引是 -3 ， 可以这样获取 hello[-3] ，
总 这个字符的索引是 -4 ， 可以这样获取 hello[-4] ，
刘 这个字符的索引是 -5 ， 可以这样获取 hello[-5] ，
负数下标有什么用处呢？
比如一个很长的字符串
str1 = 'cHl0aG9uMy52aXAlMjAlRTclOTklQkQlRTYlOUMlODglRTklQkIlOTElRTclQkUlQkQlMjAlRTclODklODglRTYlOUQlODMlRTYlODklODAlRTYlOUMlODk='
要获取最后一个元素，不需要去从前往后数下标， 一直数到最后的位置。
而是可以直接用
str1[-1]
就可以了，这样就方便了很多
3、字符串切片
sequence特性的数据对象 都支持 切片操作 ， 字符串是具有sequence特性的，当然也支持切片。
什么是切片， 形象的说，好像用刀切出其中的一部分
比如我要把
hello = '刘总你好啊'
这个字符串切出其中 你好 这部分内容，
假想我们手里有把刀，要从下面的字符串中切出 你好，就应该在箭头所示的地方切两刀，就得到 你好 这个 子字符串了
那么我们看看这两刀 对应的索引的位置。
如果用正数表示就是 2 和 4 ， Python中可以用 hello[2:4] 这样的切片表达式来得到该字符串。 大家可以运行如下代码看看
hello = '刘总你好啊'
print(hello[2:4])
当然也可以用负数表示， 就是 -3 和 -1 ， Python中可以用 hello[-3:-1] 这样的切片表达式来得到该字符串。 大家可以运行如下代码看看
hello = '刘总你好啊'
print(hello[-3:-1])
字符串切片前面的索引是切片开始的元素的 索引，后面的索引是切片结束的元素的 索引 + 1
省略一个切片索引
如果我们要得到’刘总你好啊' 当中 你好啊 这3个字 又该怎么切片呢？
可以用 hello[2:5]
我们发现，要切出的内容一直到字符串的结尾，这时还可以用 hello[2:] ，后面的索引 空着不写，表示到整个字符串的结束 。
相应的，如果 前面的索引 不写，可以表示 从字符串的开头切片， 比如 hello[:2] ，就是切出 刘总 这两个字
4、获取字符串长度
内置函数 len 可以用来获取字符串的长度，也是获取字符串中字符的个数
比如
var = '特朗普总统'
lenth = len(var)
print(lenth)
返回结果是5，因为var变量对应的字符串长度就是5个字符。
二、函数
Python中，我们是这样定义函数的：
def interview():
print("把求职者带到3号会议室")
print("请求职者 完成答卷")
print("让测试经理来面试 求职者")
print("让技术总监面试 求职者")
def 是关键字 表示定义一个函数
后面是函数的名字，紧接着后面需要一个括号 ，这个括号中间，根据需要还可以有 参数,这里我们先不讲它
最后是一个冒号，下面的缩进的代码表示这个函数名字代表的具体动作是什么，称之为函数体。
函数体的代码是需要缩进的。我们建议缩进四个空格。
这样定义好了以后，后面的代码要指代这个面试的流程，只需要写名字 interview 就行了。 比如：
print(interview)
运行一下，发现会输出内容如下
<function interview at 0x05292468>
表示这个 interview 是 一个函数类型的对象。
特别要注意的是，解释器执行到 定义函数 的语句时，并不会执行函数体里面的代码。
要执行函数体里面的代码，必须 调用函数。
Python代码怎么调用函数呢？就是在 函数名后面加上括号。
比如，要执行 interview 这个名字代表的动作，就在后面加上括号 interview()
如下：
interview()
print('后续代码')
interview() 就叫 调用函数 interview ，有时也叫做 执行函数 interview。
当解释器 执行到 这行调用函数的代码时，就会跑到 函数 interview 里面，去执行函数里面的语句。
函数必须先定义，后面才能调用。
2、调用后返回
注意，当解释器执行完被调用函数内部的代码后，还会 返回 到调用它的代码处，继续执行后面的代码。
上面的例子里面， 执行完 interview 对应的函数内部代码后， 会返回调用处，执行后面的 这条语句
print('后续代码')
3、内置函数
大家仔细看看我们的代码， 里面除了有 interview 这个函数，还有什么函数？
对了，print
其实，我们这里 print 这个名字 也是一个函数的名字， 表示一个动作就是把里面的对象 显示到屏幕上
这个动作实现的具体代码在哪里？
python语言的开发者 知道 这是我们常用的操作， 所以在python解释器内部已经帮我们实现好了 这样一个函数， 称之为内置函数。
4、函数的参数
这个print函数调用的时候，有个和我们上面定义的 interview 有明显的不同，大家有没有发现？
看看
interview()
和
print("把求职者带到3号会议室")
区别在哪里？ 对了，括号里面有内容。
函数调用括号里面的内容 称之为函数的 参数。
有的函数要完成功能，需要告诉它一些信息。
比如print函数，如果你不告诉它要打印的内容是什么，它怎么能打印信息到屏幕上呢？
参数的作用 就是： 提供 函数完成功能 所必须的信息
有参数的函数像这样
def func(para1,para2):
...
函数的参数都是放在函数定义的括号里面的。
比如上面示例代码中的 para1，para2
参数其实也是一个变量，所以他们的命名规则和变量的命名规则一样。
参数可以没有，可以是一个，也可以是多个。参数之间用逗号隔开。
调用有参数的函数时，需要传入对应个数的参数。
是一个参数，就传入一个，两个就是传入两个
我们上面interview的例子里面，如果我们要加上显示出面试者的名字，就可以这样
def interview(interviewee):
print("求职者是 " + interviewee)
print("把求职者带到3号会议室")
print("请求职者 完成答卷")
print("让测试经理来面试 求职者")
print("让技术总监面试 求职者")
interview('王小五')
我们在定义的时候，并不知道将来调用的时候是谁来面试。
但是没有关系。可以作为参数，定义在这里。
面试者来了，我们在调用函数的时候，会将面试者的名字作为参数传递过来。
在执行
interview('王小五')
的时候， 解释器就会到 函数 interview 准备去执行里面的代码，并且在执行函数代码前，会将参数变量 interviewee 赋值为 '王小五'
5、函数的返回值
什么是函数返回值
有的函数执行一个流程就完了，并不需要返回什么信息，比如 print 函数，就是打印一下参数字符串，就完成了它的任务。
但是有的函数，需要返回一个结果给调用者。
比如 计算两个数字平方和的函数，必须要返回一个结果，告诉调用代码，平方和的计算结果。
函数要返回结果，就必须要使用 return 关键字，后面加上返回的结果对象
比如：
def squarep(num1,num2):
return num1**2 + num2**2
ret = squarep(1,2)
print(ret)
语句ret = squarep(1,2) 等号右边的 就是函数调用的表达式。
解释器在执行这条语句的时候，会执行squarep函数对应的代码，函数代码最后返回一个平方和的计算结果。
这个计算结果（是一个数字对象） 就被赋值给了变量 ret
所以接下来的语句print(ret)，就可以打印出1 和 2 的平方和 计算结果 5
解释器执行代码的时候，一旦执行了函数中的 return 语句，就会立即从函数中返回到调用的地方，该函数下面还有代码，也不会再执行了。
比如
def squarep(num1,num2):
return num1**2 + num2**2
print('这条语句在return后面，不会执行')
ret = squarep(1,2)
print(ret)
如果一个函数定义，里面并没有写return语句，像这样
def func1():
print('你好')
print(func1())
那么该函数调用后会返回一个None对象。 None对象是Python内置的，表示没有数据内容的对象。
print的内容不是返回值
白月黑羽 零基础的小班学员， 经常傻傻分不清下面这两段代码有什么区别
def squarep(num1,num2):
ret = num1**2 + num2**2
print(ret)
ret = squarep(1,2)
def squarep(num1,num2):
ret = num1**2 + num2**2
return ret
ret = squarep(1,2)
他们会这样告诉我： 第1段代码运行后打印出了结果，所以函数 squarep 有返回值，而第2段代码运行后没有打印结果所以squarep没有返回值。
天哪，至少有5个小班学员有这样的误解了。
再次强调，之所以你在屏幕上能看到打印结果，是因为代码里面有print语句的原因，不是因为有返回值。
返回值要能显示在屏幕上也必须调用print打印出来。
像这样
def squarep(num1,num2):
ret = num1**2 + num2**2
return ret
ret = squarep(1,2)
print(ret)
上面第1段代码，由于没有写return语句，所以返回的是None（空对象）而不是计算结果，它只是打印了计算结果。
而第2段代码才是返回了计算平方和的结果。
6、缺省值参数
假设，我们要实现一个函数，统计考试得分超过指定分数的人数。
def overScoreStudents(studentScoreList, score):
count = 0
# 下面的代码用到了循环和判断，后面章节会学习到
for ss in studentScoreList:
if ss >= score:
count += 1
return count
在调用这个函数的时候，大部分时候 都是统计超过及格分数线60的人数。像这样
overScoreStudents(ssList,60)
所以，我们调用该函数的时候，第二个参数通常都是填写 60 。
这样显得就有些麻烦。
这时候，可以在定义函数的时候，给它加上缺省值，像下面这样：
def overScoreStudents(studentScoreList, score=60):
...
这样，在调用这个函数的时候，如果score参数还是传入60 就可以不用写了，像这样
overScoreStudents(ssList)
解释器发现该函数参数score有缺省值，就会自动帮我们传入缺省值60 给 参数score。
当然如果我们调用的时候传入了参数，比如像下面这样，解释器就会将 70 传给参数score。
overScoreStudents(ssList, 70)
函数的参数定义，一旦有缺省值后，后面所有的参数必须都有缺省值
下面这样的定义是错误的
def func(arg1, arg2, arg3=3, arg4):
...
arg4 前面的参数 arg3 已经有缺省值，所以必须也要有缺省值，比如
def func(arg1, arg2, arg3=3, arg4='hello'):
...
如果你对函数的缺省值的作用 仍然不太理解，请点击这里，观看看白月黑羽和实战班学员的1对1讲解答疑视频
指定参数名调用函数
这样的一个函数
def func(arg1, arg2, arg3=3, arg4='hello'):
print(arg1)
print(arg2)
print(arg3)
print(arg4)
我们调用的时候，可以这样
func(1,2,3,'hello')
也可以这样 指定参数名 去调用
func(arg1=1,arg2=2,arg3=3,arg4='hello')
指定参数名调用的时候，可以颠倒参数的次序
func(arg2=1,arg3=2,arg1=3,arg4='hello')
也可以这样混合使用
func( 1, 2, arg3=3,arg4='hello')
但是一旦某个参数指定了参数名，后面所有的参数必须指定参数名
像下面这样是不可以的
func( 1, 2, arg3=3, 'hello') # 错误的调用方式
变量的有效范围
点击这里，边看白月黑羽和实战班学员的1对1讲解视频，边学习下面的内容
局部变量
大家来看这样一个例子
def func(num1,num2):
ret = num1 + num2
return ret
func(1,2)
print(ret)
运行程序，可以发现 这样的错误提示
Traceback (most recent call last):
File "sample.py", line 6, in <module>
print(ret)
NameError: name 'ret' is not defined
定义在某个函数内部的变量，称之为 局部变量 。
函数的参数变量 也是 局部变量。
局部变量有效范围只能是该函数内部。
因为 ret 是 func 函数内部的 局部变量 ， 有效范围只能是 func函数内部， 不能在外部使用。
同样的，参数变量， 比如上面的 num1, num2 也是函数 内部的局部变量，这两个变量名也只能在 func函数内部使用。
全局变量
大家再来看这样一个例子
# 获取数字对应的汉字
upChars = '零壹贰叁肆伍陆柒捌玖'
def getZh(num):
print('对应的汉字是：' + upChars[num])
getZh(5)
定义在所有函数外部的变量，称之为 全局变量 。
全局变量的有效范围是整个模块文件。
上面的例子中 upChars 就是一个 全局变量。
函数内部代码 可以访问 全局变量的。
范围覆盖
大家再来看这样一个例子
upChars = '零壹贰叁肆伍陆柒捌玖'
def getZh(num):
upChars = '零一二三四五六七八九'
print('对应的汉字是：' + upChars[num])
getZh(5)
在函数内部，如果 局部变量 和 全局变量同名，使用的是 局部变量。
如果在函数内部要对全局变量进行重新赋值，不能直接这样
upChars = '零壹贰叁肆伍陆柒捌玖'
def change():
upChars = '零一二三四五六七八九'
change()
print(upChars)
因为，解释器会认为函数内部 是重新定义了一个局部变量， 而不是把全局变量进行重新赋值。
应该这样做
upChars = '零壹贰叁肆伍陆柒捌玖'
def change():
global upChars
upChars = '零一二三四五六七八九'
change()
print(upChars)
通过 global upChars 这行声明，表示 upChars 这个名字对应的是全局变量 upChars
常用 内置函数
我们通常会把常用的代码放到函数里面，这样要使用这些代码 ，只需要调用那些函数就可以了。
Python的设计者 为我们总结了一些常用的函数，放到了Python解释器中，这些函数我们直接就可以使用。
前面我们学过的print 就是其中之一。
内置函数可以在Python的官方文档查看到，点击这里查看官方文档，。
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()
我们先了解其中常用的几个
int
int 函数 经常被我们用来把一个字符串转化为对应的整数
比如
int('1000') # 返回整数1000
也经常用来把一个小数转化为对应的整数，去掉其中的小数部分
比如
int(3456.23) # 返回整数3456
float
float 函数 用来把一个字符串转化为对应的小数（浮点数）
比如
float('1000') # 返回 浮点数 1000.0
float('6.345') # 返回 浮点数 6.345
也可以把一个整数对象转化为对应的小数对象
比如
float(1000) # 返回浮点数 1000.0
str
str 函数 用来得到一个对象的字符串表示。
经常被我们用来把数字转化为对应的字符串表示的数字
比如
str(1000) # 返回字符串 '1000'
str(1000.23) # 返回字符串 '1000.23'
len
len 函数 可以得到一个数据对象的长度，通常用来获取 字符串、列表、元组、字典等类型对象的元素个数。
比如
print (len('你好！'))
可以得到字符串的长度 3
type
type 函数 可以得到一个数据对象类型
比如
type(3) # 返回 <class 'int'>
type('hello') # 返回 <class 'str'>让用户输入信息
终端
想象一下，你如果要开发一个计算税后薪资的软件，需要用户输入员工的薪资，怎么做？
当然可以开发一个带图形界面的程序，但是图形界面的开发需要更多的基础知识，我们先学习如何在终端上，让用户用键盘输入信息。
可能你要问了，什么叫终端？
终端这个名词，历史悠久，感兴趣的同学可以参考这篇文档 终端
这里，我们可以先简单说，就是命令行窗口。就是这个
这个就是我们常说的终端窗口
输入输出
我们写的程序目前都是使用这个窗口 输出信息 ，和 输入信息 。
前面我们学过使用Python的内置函数 print 输出 信息到屏幕上。
那么，我们怎么让用户 输入 信息给程序呢？
这时我们需要使用另一个内置函数 input
比如
salary = input('请输入张三的薪资：')
print(salary)
input 函数里面的参数是个字符串， 它是 让用户输入之前，显示在屏幕上的提示信息
大家运行一下，就可以发现，
解释器在执行到第一行代码input处
会停止执行代码，等待用户输入员工的薪资。如果用户没有输入结束，就一直停止在这里，不会执行下面的代码。
输入薪资数字后，用户敲一个回车符，结束输入。 这时 input函数才会返回用户输入的内容，并继续执行下面的代码 print(salary)
input函数返回值是 用户输入的字符串，不包括最后的回车符。
要注意，input函数返回的用户输入的内容，都是 字符串 。
即使用户输入的是一个数字，返回的也是 一个 内容为数字 的 字符串
如果我们想根据用户输入的薪资计算出税后薪资（扣税15%），该怎么办？
能不能这样？
salary = input('请输入张三的薪资：')
print('税后薪资是：' + salary*75/100 )
运行一下，发现有错误
TypeError: unsupported operand type(s) for /: 'str' and 'int'
因为字符串 是不能 进行数学运算的
要解决这个问题，可以使用两个内置函数， int 和 str
int把字符串转化为对应的数字
int('1000') 返回的结果就是 数字 1000
str把数字转化为对应的字符串
str(1000) 返回的结果就是 字符串 '1000'
那么大家想想 ，我们该怎么做呢？
对了，可以这样
salary = input('请输入薪资：')
# 先将字符串转化为数字
intSalary = int(salary)
# 计算出税后薪资
realSalary = intSalary*75/100
# 再转化为字符串，方便下面的字符串拼接
realSalaryStr = str(realSalary)
print('税后薪资是：' + realSalaryStr)
上面的代码可以将中间的语句合并到一个表达式str(int(salary)*75/100)里面
代码可以写成这样
salary = input('请输入张三的薪资：')
print('税后薪资是：' + str(int(salary)*75/100))三、列表与元组、字典
python中的 列表(英文叫list) 和 元组(英文叫tuple) 也是 序列 特性的，它们也是非常常用的数据类型。
列表
列表（List）对象 经常被用来 存储 数据对象。
我们可以把列表想象为 一连串的储物格，就像下面这样
其中每个储物格里面都可以存储 任何类型 的对象
注意：是任何类型的对象， 整数、小数、字符串、函数、等等 都可以。 也可以存储另一个列表对象。
Python代码中，我们可以这样定义一个空的列表，赋值给一个变量
nameList = []
方括号用来表示一个列表。
如果定义列表的时候，里面就存放了一些数据对象，只需要填写到方括号里面就可以了。每个对象之间用逗号隔开。比如
a = [1, 2, 3.14, 'hello']
这个列表里面就包含了多种类型的对象: 整数、小数 、 字符串。
列表里面的每个对象，就称之为列表的一个元素。
甚至还可以包含另一个列表作为元素，如下
a = [1, 2, 3.14, 'hello', [7,8,9] ]
最后一个元素 就是 另外的一个列表对象 [7,8,9]
列表的sequence操作
刚才说了，列表也是有sequnce特性的。当然也支持sequence操作。
就是：
可以用元素索引的方式取出里面的元素; 也可以用切片操作 截取一部分内容生成新的列表。
列表的 索引和切片操作和 字符串是 类似的。
比如上面的列表，其索引如下所示
列表每个元素的索引是从0开始的，支持正数索引，也支持负数索引
a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0] # 就是 1
a[1] # 就是 2
a[4] # 就是 [7,8,9]
a[-1] # 也是 [7,8,9]
a[-4] # 也是 2
a[-1][0] # a[-1] 是[7,8,9], a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
列表的切片也和字符串类似，想象用刀去切取其中的一部分，该在哪里下刀，就使用哪里的索引
a = [1, 2, 3.14, 'hello', [7,8,9] ]
a[0:3] # 结果是 [1, 2, 3.14]
a[:3] # 结果也是 [1, 2, 3.14]
a[3:5] # 结果是 ['hello', [7,8,9] ]
a[3:] # 结果也是 ['hello', [7,8,9] ]
a[-1][:2] # 结果是 [7,8] 为什么？ 自己想一想
print(a)
# 结果还是 [1, 2, 3.14, 'hello', [7,8,9] ]
# 上面对a的切片操作是产生新的对象，并不会改变a指向的对象
改变列表内容
和我们前面学过的其它数据类型不同，列表对象有个特点，它的内容是可以变化的
比如
a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)
a[0] = '你好'
print(a)
执行上面的代码，可以发现，最后列表变量 a 的内容变成了
['你好', 2, 3.14, 'hello', [7, 8, 9]]
如果这样写
a = [1, 2, 3.14, 'hello', [7,8,9] ]
print(a)
a[-1][-1] = '你好'
print(a)
就改变了列表里面的列表 的内容，a就变成了
[1, 2, 3.14, 'hello', [7, 8, '你好']]
列表的元素也可以填写变量，比如
var = [7, 8, '你好']
a = [1, 2, 3.14, 'hello', var]
print(a)
结果a的值是
[1, 2, 3.14, 'hello', [7, 8, '你好']]
列表的元素还可以填写表达式，解释器会自动计算结果，放入列表中，比如
var = 100
a = [1, 2, var*3 + 20, 'hello', [7, 8, '你好']]
print(a)
结果a的值是
[1, 2, 320, 'hello', [7, 8, '你好']]
如果我们只是要把下面的列表
list1 = [0, 1, 2, 3, 4, 5]
其中 1,2,3 换成 a,b,c ， 该怎么做呢？
当然可以这样
list1[1] = 'a'
list1[2] = 'b'
list1[3] = 'c'
但是一个个的写有点麻烦，列表支持 这样一部分内容 整体替换
list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = ['a','b','c']
结果 list1 就变成了 [0, ‘a’, ‘b’, ‘c’, 4, 5]
这种写法称之为 切片赋值
切片赋值 甚至支持 替换的元素 比 被替换的元素 多， 像这样
list1 = [0, 1, 2, 3, 4, 5]
list1[1:4] = ['a','b','c','e','f','g','h']
结果 list1 就变成了 [0, ‘a’, ‘b’, ‘c’, ‘e’, ‘f’, ‘g’, ‘h’, 4, 5]
合并两个列表
列表中要添加另外一个列表的内容很简单，用加号就可以了
>>> a = [1,2,3]
>>> a += [4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
元组
元组（Tuple）也是一种sequence特性的类型， 它和列表非常相似，也可以存放任何类型的数据对象，除了一点： 元组的内容是 不能改变 的
Python代码中，我们可以这样定义一个空的元组，赋值给一个变量
nameList = ()
圆括号用来表示一个元组。
如果定义元组的时候，里面就存放了一些数据对象，只需要填写到括号里面就可以了。每个对象之间用逗号隔开。
比如
a = (1, 2, 3.14, 'hello')
这个元组里面就包含了多种类型的对象: 整数、小数 、 字符串。
元组里面的每个对象，就称之为元组的一个元素。
甚至还可以包含另一个列表或者元组作为元素，如下
a = (1, 2, 3.14, 'hello', [7,8,9] )
最后一个元素 就是 另外的一个列表对象 [7,8,9]
如果元组中只有一个元素，必须要在后面加上逗号，像这样
a = (1, )
否则 这样写的话
a = (1)
a就是 数字1 了， 而不是包含 数字1 的元组
定义元组还可以去掉圆括号，像这样
a = 1, 2, 3.14, 'hello'
但是这样定义的时候，如果元组中只有一个元素，必须要在后面加上逗号，像这样
a = 1,
元组的sequence操作
刚才说了，元组也是有sequnce特性的。当然也支持sequence操作。
就是支持用元素索引的方式取出里面的元素; 也支持用切片操作 截取一部分内容作子列表。
元组的 索引和切片操作和 列表、字符串是 类似的。
比如
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] # 就是 1
a[1] # 就是 2
a[4] # 就是 [7,8,9]
a[-1] # 也是 [7,8,9]
a[-4] # 也是 2
a[-1][0] # a[-1] 是[7,8,9], a[-1][0] 就是 [7,8,9] 里面的第一个元素，就是 7
元组的切片也和字符串类似，想象用刀去切取其中的一部分，该在哪里下刀，就使用哪里的索引
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0:3] # 结果是 (1, 2, 3.14)
a[:3] # 结果也是 (1, 2, 3.14)
a[3:5] # 结果是 ('hello', [7,8,9])
a[3:] # 结果也是 ('hello', [7,8,9])
a[-1][:2] # 结果是 [7,8] 为什么？ 自己想一想
元组内容不可变
和列表不同，元组对象的内容是不可以变化的
比如
a = (1, 2, 3.14, 'hello', [7,8,9])
a[0] = '你好'
执行上面的代码，解释器会报如下错误
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
意思是说元组的内容是不可以改变的。
但是元组中的列表的内容却是可以改变的，比如
a = (1, 2, 3.14, 'hello', [7,8,9])
a[-1][0] = '你好'
print(a)
结果 a的值就变成了
(1, 2, 3.14, 'hello', ['你好', 8, 9])
判断元素是否在列表或元组中
有时候，我们要检查列表、元组对象中是否存储我们要找的元素。 我们可以通过 in 这个关键字 ，比如
a in var # 检查 a 是否在var 中存在，存在返回True，否则返回False
而 not in 则判断是否不存在，比如
a not in var # 检查 a 是否不在var 中，存在返回 False，否则返回 True
具体的例子如下：
list1 = [1,2,3,4, 'hello']
tuple1 = (1,2,3,4, 'hello')
if 'hello' in list1:
print('hello 在列表中存在')
if 'boy' not in tuple1:
print('boy 在元组中不存在')
多个变量同时赋值
我们可以像下面这样把 列表 或者 元组 中的元素直接赋值给变量
x,y = (1,2) # x 的值为 1， y 的值为 2
print(x,y)
name, age = ['李逵', 33] # name 的值为 '李逵'， age 的值为 33
print(name,age)
但是注意，这样赋值，变量的个数一定要和 列表/元组 中元素的个数相等。
像下面这样就会出错了
x,y = (1,2,3)
b,c = [1]
函数返回列表或者元组
函数的返回值可以是一个列表或者 元组对象，像这样
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return [age,gender]
当我们有多个数据对象需要在函数里面返回的时候，就可以放到列表中。
当然也可以放到元组中返回，像这样
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return (age,gender)
如果是放在元组中返回，可以简单写成这样
def func1():
age = input('请输入年龄')
gender = input('请输入性别')
return age,gender
因为元组的括号是可以省略的
字典是什么
目前为止，Python中最常用的数据类型，我们只剩下一个 字典 还没有给大家介绍了。
字典，是Python开发中非常重要的一种数据类型。
为什么呢？ 因为字典 提供了一种特别的结构， 就是 存放 键值对 数据。这种结构使得字典，特别像 一张 表
什么是键值对数据？
举个例子， 一个游戏系统 里面会存储 用户信息。
系统 经常需要 查询某个用户的信息，比如 某个用户的等级、装备等。
那么根据什么去查找该用户的信息呢？ 根据 唯一标志 该用户的属性，比如 用户登录名 或者 用户分配的ID号 等。
根据 登录名1 就查到 用户1 的信息
根据 登录名2 就查到 用户2 的信息
这样就形成了如下 的一种 从 登录名 到 用户信息数据 的映射关系
上图中
登录名1就是键（英文叫Key）， 用户1 就是值（英文叫Value）；
登录名2就是键， 用户2就是值。
每个对应的帐号 和 会员数据 就形成了一个键值对。
要存储像这样 一对一 的映射关系的数据结构，就像一张表一样，在Python中就可以使用字典这种数据类型。
字典的定义
字典对象定义用花括号 {} , 字典里面的 每个元素之间用 逗号 隔开。
每个元素都是一个键值对，键和值之间用 冒号 隔开。
上面例子中，如果每个帐号的信息比较简单，比如只有等级信息，就定义成这样
members = {
'account1' : 13 ,
'account2' : 12
}
上面的字典对象 键就是帐号，值就是一个数字对象，表示等级的数字。
注意，字典元素的 键 必须是 可进行哈希值计算 的对象， 通常是 数字 或者 字符串。
而 字典元素的 值 可以是任何类型的 对象，包括 数字、字符串、列表、元组、字典、自定义类型 等等均可。
什么是 哈希值计算？ 大家可以大体理解为 一种算法，可以根据一个原始数据，计算出一个结果数据，而且不同的原始数据，哪怕只有一丁点的不同，计算出的结果数据都不同。
上例中，用户账号信息，如果复杂一些，包括 等级、点卡数，可以是这样的
members = {
'account1' : {'account':'account1', 'level': 13, 'point':3000} ,
'account2' : {'account':'account2', 'level': 12, 'point':36000}
}
上面的字典对象 键就是帐号，值也是一个字典对象。 这个值字典对象中又 包含了 帐号、等级、积分信息。
字典对象的一个特点就是 ： 根据 键 去查找 值 非常的方便高效，
比如 members['account1'] 就可以得到 键为 ‘account1’ 的 元素的值
members = {
'account1' : 13 ,
'account2' : 12
}
print(members['account1'])
最后一句代码打印出的结果就是 13
字典对象可以存储非常多的元素。理论上 只要内存够大，字典的元素的数量是没有限制的。
字典对象 存储元素有特别的优化， 根据 键 查找值的效率非常高，速度非常快，特别适合查找数据这样的操作。
字典对象的键是唯一的，不可能有两个元素具有相同的键。如果我们这样定义一个字典对象
members = {
'account1' : 13 ,
'account1' : 12
}
print(members)
就会发现输出的结果是
{'account1': 12}
相同的键，后面的元素会替换前面的元素。
根据键去获取值，是这样的语法 var[key] 。
如果给出的 key 在 var 这个字典中不存在就会报错了。
比如
members = {
'account1' : 13 ,
'account2' : 12
}
print(members['account99'])
就会出现这样的错误，说明key不存在
KeyError: 'account99'
添加、修改、删除
像列表对象一样，字典对象的内容是 可以改变 的。
我们可以这样定义一个空字典
members = {}
要在字典对象中添加元素非常简单，像这样
members['account1'] = 13
members 的内容就变成了
{
'account1' : 13
}
继续添加元素
members['account2'] = 12
members 的内容就变成了
{
'account1' : 13 ,
'account2' : 12
}
如果我们要修改一个元素key对应的value为另外的值，也是这样
members['account2'] = 88
members 的内容就变成了
{
'account1' : 13 ,
'account2' : 88
}
大家可以发现：
像这样的赋值语句
var[key] = something
括号里面的key：
-
如果在字典中不存在，就是添加元素的的操作，
-
如果已经存在，就是重新赋值操作。 因为字典不允许有相同的key
如果我们要删除一个元素，可以使用字典对象的pop方法。 像这样
members = {
'account1' : 13 ,
'account2' : 12
}
val = members.pop('account1')
print(members)
print(val)
pop方法还会返回参数 key 对应的 value 对象，所以上面的代码执行后，变量val 的值就是 13
而members 的内容则变成了
members = {
'account2' : 12
}
也可以使用 del 关键字来删除一个元素，比如
del members['account1']
判断字典是否存在某个key
有时候，我们要检查字典的key中，是否有我们要找的元素，可以通过 in 这个关键字 ，比如
a in var # 检查 a 是否在var 中存在，存在返回True，否则返回False
而 not in 则判断是否不存在，比如
a not in var # 检查 a 是否不在var 中，存在返回 False，否则返回 True
具体的例子如下：
members = {
'account1' : 13 ,
'account2' : 12
}
if 'account1' in members:
print('account1 在字典中存在')
if 'account88' not in members:
print('account88 不在字典中')
访问字典的所有元素
我们有时需要访问字典的每一个元素，也叫遍历字典。
比如，我们需要打印出下面 会员信息字典 中的 每个会员的等级。怎么办？
通常我们使用字典对象的items方法，像这样：
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
for account,level in members.items():
print (f'account:{account}, level:{level}')
items方法，返回的是一个类似列表一样的对象，其中每个元素就是 键值组成的元组
上面的字典，其items方法返回的是类似这样的对象
[('account1', 13), ('account2', 12), ('account3', 15)]
用for 循环， account level 两个变量就依次对应其中的每个元组里面的 两个元素，完成遍历。
其他常用方法
得到所有的 key 和value 对象
前面我们介绍了 items 方法， 返回的是 将字典 所有的 键值对元组 存入的 一个类似列表的对象
比如：
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members.items()
返回的是类似这样的对象
[('account1', 13), ('account2', 12), ('account3', 15)]
而字典还有 keys 方法， 返回的是 将字典 所有的 键 存入的 一个类似列表的对象
比如：
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members.keys()
返回的是类似这样的对象
['account1', 'account2', 'account3']
而字典还有 values 方法， 返回的是 将字典 所有的 值 存入的 一个类似列表的对象
比如：
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members.values()
返回的是类似这样的对象
[13, 12, 15]
清空字典
clear 方法可以清空字典对象里面的所有元素
比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members.clear()
print(members)
可能有的朋友就想，我们给字典对象重新赋值不也就等于清空字典吗？
比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
members = {}
print(members)
这两种做法，虽然最后 members 变量指向的对象 都是一个空字典。 但是最大的区别就在于
clear方法， members 变量 指向的还是原来的字典对象。
而 重新赋值的方法， members 变量 指向的 就是一个新的空字典对象。 原来的字典对象呢？ 因为没有被引用，就会被Python解释器在合适的时候 从内存中清除掉。
和另外一个字典合并
有的时候，我们需要把字典里面加上另外一个字典的内容， 可以使用update方法，比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
another = {
'account4' : 13 ,
'account5' : 12 ,
}
members.update(another)
print(members)
这样，就在 members字典里面加上了 another字典里面的所有元素。
得到字典元素的个数
如果需要得到字典元素的个数，就使用Python的内置函数 len 即可
比如
members = {
'account1' : 13 ,
'account2' : 12 ,
'account3' : 15 ,
}
print(len(members)) # 结果为3，表示字典中有3个元素四、判断
布尔对象
Python中有一种对象类型称之为布尔对象（英文叫 bool）。
布尔对象只有两种取值： True 和 False
对应 真 和 假， 或者说 是 和 否。
很多事情只有两种可能，是 或者 否。
比如： 今天是星期天吗？
要么 是 ，要么 否。
Python中的布尔对象 对应 是 和 否 只有两种取值。
其中 True 对应 是， False 对应 否。
布尔表达式
运算结果是布尔对象的表达式，就是 布尔表达式。
通常有如下几种
是否相等
是否相等的表达式 像这样
1 == 1
用 == 连接两个比较对象。
如果 两个比较对象相等，解释器运算结果为 True
如果不相等，解释器运算结果为 False
请运行Python解释器命令行，输入如下语句
1 == 1
返回值为 True
1 == 2
返回值为 False
1 == '1'
返回值为 False。想一想，为什么？
'1' == '1'
返回值为 True
是否不相等
用 != 连接两个比较对象。
如果两个比较对象不相等，解释器运算结果为 True
如果相等，解释器运算结果为 False
请运行Python解释器命令行，输入如下语句
1 != 1
返回值为 False
1 != 2
返回值为 True
1 != '1'
返回值为 True
'1' != '1'
返回值为 False
是否大于
用 > 连接两个比较对象。
如果前面的对象大于后面的对象，解释器运算结果为 True
否则，运算结果为 False
请运行Python解释器命令行，输入如下语句
1 > 1
返回值为 False
1 > 0
返回值为 True
1 > 2
返回值为 False
是否大于等于
用 >= 连接两个比较对象。
如果前面的对象大于或者等于后面的对象，解释器运算结果为 True
否则，运算结果为 False
请运行Python解释器命令行，输入如下语句
1 >= 1
返回值为 True
1 >= 0
返回值为 True
1 >= 2
返回值为 False
是否小于
用 < 连接两个比较对象。
如果前面的对象小于后面的对象，解释器运算结果为 True
否则，运算结果为 False
请运行Python解释器命令行，输入如下语句
1 < 1
返回值为 False
1 < 0
返回值为 False
1 < 2
返回值为 True
是否小于等于
用 <= 连接两个比较对象。
如果前面的对象小于或者等于后面的对象，解释器运算结果为 True
否则，运算结果为 False
请运行Python解释器命令行，输入如下语句
1 <= 1
返回值为 True
1 <= 0
返回值为 False
1 <= 2
返回值为 True
连写比较表达式
比较的表达式可以 连着写 ，像这样
num = 3
2 < num <= 5
返回值为 True，这个表达式 2 < num <= 5 等价于
num > 2 and num <=5
条件组合
有的时候，布尔表达式 还会 组合起来 成为一个更大的表达式
布尔表达式 主要有3 种组合关系
逻辑且
这种组合关系是用 and 关键字 连接的，如下
表达式1 and 表达式2
这种组合，只有表达式1 和 表达式2 都成立 （也就是计算结果都为True），最终的结果才成立(为True)
任何一个表达式为 False ，结果都是False
你可以打开Python解释器，依次输入如下的语句，看看结果是什么
True and True # 结果为 True
True and False # 结果为 False
False and True # 结果为 False
False and False # 结果为 False
num1 = 5
str1 = 'ok'
num1 > 4 and str1 == 'ok' # 结果为 True
num1 > 4 and str1 == 'bad' # 结果为 False
num1 > 6 and str1 == 'ok' # 结果为 False
num1 > 6 and str1 == 'bad' # 结果为 False
num1 > 4 and str1 == 'ok' and num1 > 5 # 结果为 False
逻辑或
这种组合关系是用 or 关键字 连接的，如下
表达式1 or 表达式2
这种组合，只要表达式1 和 表达式2 任何一个成立 （也就是任何一个计算结果为True），最终的结果都成立(为True)
如果两个表达式计算结果都为 False ，结果才是False
你可以打开Python解释器，依次输入如下的语句，看看结果是什么
True or True # 结果为 True
True or False # 结果为 True
False or True # 结果为 True
False or False # 结果为 False
num1 = 5
str1 = 'ok'
num1 > 4 or str1 == 'ok' # 结果为 True
num1 > 4 or str1 == 'bad' # 结果为 True
num1 > 6 or str1 == 'ok' # 结果为 True
num1 > 6 or str1 == 'bad' # 结果为 False
num1 > 6 or str1 == 'ok' or num1 != 5 # 结果为 True
num1 > 6 or str1 == 'sk' or num1 != 5 # 结果为 False
如果 and 和 or 一起使用， 注意 是先计算 and 部分， 其结果 再和 or 一起计算，比如这个表达式
6 > 5 or 'sk' == 'sk' and 4 == 5
就要先计算
'sk' == 'sk' and 4 == 5
结果是 False
然后这个False 再和前面的计算，就是
6 > 5 or False
所以最后的结果是True
如果我们就是想要： 先计算前面的or 部分， 然后再和 后面 and 一起计算呢？
可以使用括号，像这样
(6 > 5 or 'sk' == 'sk') and 4 == 5
就要先计算
(6 > 5 or 'sk' == 'sk')
结果是 True
然后这个结果 True 再和前面的计算，就是
True and 4 == 5
所以最后的结果是False
可以看出， 不用的优先级会导致不同的结果
逻辑非
这种组合其实就是把后面的布尔表达式的结果反过来
这种组合关系是用 not 关键字 的，如下
not 表达式1
not 加在条件表达式1的前面，会反转其结果。
表达式1 计算结果为True， 最终的结果为 False
表达式1 计算结果为False，最终的结果为 True
你可以打开Python解释器，依次输入如下的语句，看看结果是什么
not True # 结果为 False
not False # 结果为 True
num1 = 5
str1 = 'ok'
not num1 > 4 # 结果为 False
not str1 == 'sk' # 结果为 True
如果not、 and 和 or 一起使用， 注意 是先计算 not ， 再计算 and 部分， 最后再计算 or
这样的表达式
not 4 > 6 or 'sk' == 'ok' and 4 > 3
先计算 not 4 > 6 得到 True
再计算 'sk' == 'ok' and 4 > 3 得到 False
将上面的结果 用 or 连接 ，就是 True or False ，所以最后结果是 True
如果大家想了解完整的Python运算符的优先级,可以点击这里，参考官网操作符优先级表
判断语句
上面的这些布尔表达式都表示了一个结果， True 还是 False。
那么这些表达式有什么用呢？
主要是用在判断语句中。
判断语句是根据 某个条件 决定是否要执行一些代码。
判断语句是以 if 关键字开头。
来看下面的例子，实现一个注册用户手机信息的函数，输入的手机号码不能超过11位。
def registerUser():
phone = input('请输入你的手机号码(不超过11个字符)：')
if len(phone) > 11:
print('输入错误！手机号码超过了11个字符')
print('函数结束')
如果 if 关键字 后面的条件 对应的表达式 运算结果 为 True ，就表示条件成立，就去执行 下面缩进的 代码。
如果 if 后面的表达式结果为 False 就不会执行它 。
有的时候，程序 不仅仅 判断在某个条件成立时，做一些处理， 还要求 在这个条件不成立时 ，做另外的处理。
if 后面的条件不成立要做什么，Python 中 用 else 关键字，
比如，我们要求 如果用户输入的 手机号码长度正确，要给出输入正确的提示
def registerUser():
phone = input('请输入你的手机号码(不超过11个字符)：')
if len(phone) > 11:
print('输入错误！手机号码超过了11个字符')
else:
print('手机号码输入正确')
print('函数结束')
注意， else 和 if 对齐，else 情况下的代码 也要缩进。
else 表示在 if 后面的条件不成立时，要做一些事。 if ... else 构成了一种 非此即彼 的判断关系。
有的时候，在if 条件不成立的情况下， 要做什么， 还需要进一步的判断 ， 不能简单的就用一个else 来表示。
比如：用户输入的手机号码 长度不超过11个字符 条件满足，不能就直接判定 手机号码输入正确， 还得判断输入的 是不是都是数字 。
这时候， 可以这样写
def registerUser():
phone = input('请输入你的手机号码(不超过11
最低0.47元/天 解锁文章
1396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
