学习phyton的基础知识

phyton

数据类型

数据类型：

1整数：1，1，10
2浮点型：1.0，2.0，3.0
3字符串：它里面可以是任意语言的字符例如”中国“，“China"， ”chino“。也可以有一个字母：”c“
字符串与整形，浮点型区别在字符串必须加单引号，或双引号如
‘ ’，“ ”
100与“100”的区别一个整形一个字符串。

数据运算(整形，浮点型的运算)

加法：
2+3=5
减法：
3-2=1
乘法：
2*3=6
除法：
6/2=3
求余：
6/5=1
次方：
>2**3=8        #只有两个**
整除：
9\\4=2      #要有两个\\
求余数
6%2=0
6%4=2

比较运算（整形与浮点型的运算）

——————————————布尔值(Flase,Ture)
2>3
Flase 错误
2<3
Ture 正确
比较运算的运算符:
大于（>），
小于（<），
大于等于（>=），
小于等于（<=），
等于（==），
不等于（!=）。
=是赋值
其写法与数学中的比较运算很相似，但不同的是「等于」和「不等于」，尤其注意「等于」是用两个等号 == 表示。
#布尔值用于while和if
True看成非零的数：1，False看成0

变量

变量其实就是编程者给代码中的某个数据所取的名字，之后的编程过程中使用这个名字就相当于使用它背后的数据。简单地来理解的话，我们可以把变量看作是代码中用于保存数据的临时容器。
创建变量的动作我们称之为定义变量。
如

a=60*60*24    #一天多少秒
b=a*7         # 一周多少秒
priant(b)    #print()：输出函数就可以输出一周多少秒。

在Python中使用变量时

需要遵守一些规则和指南。违反这些规则将引发错误，而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。
1：变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
2：变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greetingmessage会引发错误。
3：不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print。
4：变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
5：慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。
注意：
1 “函数：print(变量名）变量名要前后一致。”
2 “计算机一丝不苟，但不关心拼写是否正确。因此，创建变量名和编写代码时，你无需考虑英语中的拼写和语法规则。”

列表（list）

表示中:[]
z=5 整数
c=2.0 浮点型
z=‘八嘎雅鹿’ 字符型
d=Ture 布尔值
c=none 空字符
如果想要把三种类型数据发在一起就要引入列表
c=[5,2.0,'八嘎雅鹿‘]每种数据类型在列表称作元素
注意每种元素必须以逗号隔开

列表的索引

列表中的每个数据项都是有先后次序的，最前面的数据项的位置编号为 0，之后依次是 1 ，2 …… N，这个位置编号在编程中的术语叫做索引（Index）。注意 Python 中索引是从 0 开始计数的，0 即代表第一个位置。

可以通过符号 [ ] 来获取某个索引所对应的数据项。比如：

suoyin=[1,66,'玛卡巴卡','Bulusi',3.0]
print(suoyin[-1])
print(suoyin[1])
print(suoyin[3])
print(suoyin[0],suoyin[4])
print(suoyin[5])

3.0
66
Bulusi
1 3.0
Traceback (most recent call last): 报错
File “D:/PycharmProjects/111/take down.py”, line 11, in
print(suoyin[5])
IndexError: list index out of range ：报错原因

扩展print为输出函数

索引可以是负数其意是倒数第几个元素
**注意：索引时索引的数不能超过元素个数
意思是：当列表中的元素是8个当你想要索引时中括号[]只能填比7小的数
如果超过就会报错：
扩展：这是 Python 的典型报错形式，这里有三行内容（也可能会有很多行），前两行是错误定位，描述出错的位置（如某文件的某行），后面是错误描述，指出这是个 IndexError 错误，具体信息为「list index out of range」列表索引超出范围。
**当索引数据为负数时，倒着数第几个就可以了
意思就是：当索引数为-2时就是倒数第二个数
除了通过索引去获取值，也可以通过索引去改变列表中某项数据的值。通过赋值的方式来实现：

suoyin[0]='鸡腿’
print(suoyin[0]）

鸡腿

修改、添加和删除元素

列表是动态的，可以随着程序运行而改变。继而可以对列表的元素修改，添加，删除。
修改：

dining_room=["羊汤","牛汤","胡辣汤","白米粥"]
print(dining_room)
dining_room[0]="羊杂汤"		#对列表的元素修改
dining_rom[1]="牛杂汤“
print(dining_room)

[‘羊汤’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊杂汤’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
['羊杂汤‘，’牛杂汤‘，’胡辣汤‘，’白米粥‘]

*在列表中添加元素

函数append()在列表末尾添加元素

dining_room=["羊汤","牛汤","胡辣汤","白米粥"]
print(dining_room)
# dining_room[0]="羊杂汤"
# print(dining_room)
dining_room.append("葱花饼")		#函数append()就是在列表末尾添加元素

print(dining_room)

[‘羊汤’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊汤’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’, ‘葱花饼’]

在列表中插入元素

函数insert()可以在列表任何位置添加元素。
insert(索引位置，”要添加的元素“）

dining_room=["羊汤","牛汤","胡辣汤","白米粥"]
print(dining_room)
# dining_room[0]="羊杂汤"
# print(dining_room)
# dining_room.append("葱花饼")
# print(dining_room)
dining_room.insert(0,"羊杂汤加饼丝")
dining_room.insert(2,"胡辣汤加豆腐脑")
print(dining_room)

[‘羊汤’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]

从列表中删除元素

.使用函数del 语句删除元素，但需要知道元素的位置

del 变量[]

dining_room=['羊杂汤加饼丝', '羊汤', '胡辣汤加豆腐脑', '牛汤', '胡辣汤', '白米粥']
print(dining_room)
del dining_room[0]
del dining_room[4]
print(dining_room)

[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’]

del删除是对列表删除。无法恢复

使用函数pop() 删除元素

函数pop() 可删除列表末尾的元素，并让你能够接着使用它。术语弹出 （pop）源自这样的类比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

dining_room=['羊杂汤加饼丝', '羊汤', '胡辣汤加豆腐脑', '牛汤', '胡辣汤', '白米粥']
print(dining_room)
dining=dining_room.pop()
print(dining_room)
print(dining)

[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’]
白米粥

** 弹出列表中任何位置处的元素**
实际上，你可以使用pop() 来删除列表中任何位置的元素，只需在括号中指定要删除的元素的索引即可。

dining_room=['羊杂汤加饼丝', '羊汤', '胡辣汤加豆腐脑', '牛汤', '胡辣汤', '白米粥']
print(dining_room)
dining=dining_room.pop()
dinings=dining_room.pop(1)
print(dining_room)
print(dining)
print(dinings)

[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊杂汤加饼丝’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’]
白米粥
羊汤

注意：函数pop（）就把元素重列表剔除
如果你不确定该使用del 语句还是pop() 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del 语句；如果你要在删除元素后还能继续使用它，就使用方法pop() 。

**根据值删除元素：函数remove

若我们不知道元素的位置，但知道元素的值，那我们就可以调用函数remove()。函数remove把元素重列表剔除也可以接着用。

dining_room=['羊杂汤加饼丝', '羊汤', '胡辣汤加豆腐脑', '牛汤', '胡辣汤', '白米粥']
print(dining_room)
ding="牛汤"		# 使用是把元素赋给新的变量
dining="胡辣汤"
dining_room.remove("牛汤")
dining_room.remove("胡辣汤")
print(dining_room)
print(dining)

[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘牛汤’, ‘胡辣汤’, ‘白米粥’]
[‘羊杂汤加饼丝’, ‘羊汤’, ‘胡辣汤加豆腐脑’, ‘白米粥’]
胡辣汤
牛汤

组织列表

使用方法sort() 对列表进行永久性排序
按首字母排序

word=['dog','cat','pag','monkey']
word.sort()
print(word)

[‘cat’, ‘dog’, ‘monkey’, ‘pag’]

如果首字母有大写的先排大写的，首字母也是按字母顺序排列。

word=['dog','cat','pag','monkey','Panda','Duck']
word.sort()
print(word)

[‘Duck’, ‘Panda’, ‘cat’, ‘dog’, ‘monkey’, ‘pag’]

按数字大小排序

word=[6,6666,555,3,]
word.sort()
print(word)

[3, 6, 555, 6666]

汉语排序：
如果列表的元素是汉语，因为stor是参照编码大小进行排序的，汉字对应的编码顺序，本身就是杂乱的，所以使用sort排序结果自然无规则可言。所以你首先要有自己的排序规则，比如按拼音字母，笔画多少。然后再创建排序规则（可以是一个文本文件、也可以保存到数据库、也可以做个列表保存）。
最后用匿名函数配合sort就行排序。
当然，网上也是有很多网友提供现成代码参考。

当数字与字符混合时。
如果直接使用数字会报错
但如果把数字变为字符型则不会报错

word=['dog','cat','pag','monkey','Panda','Duck','44','55','100']
word.sort()
print(word)

[‘100’, ‘44’, ‘55’, ‘Duck’, ‘Panda’, ‘cat’, ‘dog’, ‘monkey’, ‘pag’]

使用函数sorted() 对列表进行临时排序

word=['dog','cat','pag','monkey','Panda','Duck','44','55','100']
print(sorted(word))
print(word)

[‘100’, ‘44’, ‘55’, ‘Duck’, ‘Panda’, ‘cat’, ‘dog’, ‘monkey’, ‘pag’]
[‘dog’, ‘cat’, ‘pag’, ‘monkey’, ‘Panda’, ‘Duck’, ‘44’, ‘55’, ‘100’]

倒着打印列表

调用函数reverse()可以倒着打印列表的元素。(就是反转列表的元素）

word=['dog','cat','pag','monkey','Panda','Duck','44','55','100']
# print(sorted(word))
# print(word)
word.reverse()
print(word)

[‘100’, ‘55’, ‘44’, ‘Duck’, ‘Panda’, ‘monkey’, ‘pag’, ‘cat’, ‘dog’]

注意函数reverse是永久性改变列表，但如果想要改变可以再次调用函数reverse

word=['dog','cat','pag','monkey','Panda','Duck','44','55','100']
# print(sorted(word))
# print(word)
word.reverse()
print(word)
word.reverse()
print(word)

[‘100’, ‘55’, ‘44’, ‘Duck’, ‘Panda’, ‘monkey’, ‘pag’, ‘cat’, ‘dog’]
[‘dog’, ‘cat’, ‘pag’, ‘monkey’, ‘Panda’, ‘Duck’, ‘44’, ‘55’, ‘100’]

列表的长度（计算列表的元素个数）

列表中数据项的个数，叫做列表（的）长度。
想要获得列表的长度可以使用 len() 这个函数。
例如：

c=len(suoyin)
print(c)          
或print（len（suoyin））

6

向列表的末尾添加数据可以用 .***append()***这个函数，

它的写法是：

x=['鸡腿','红烧肉','梅菜扣肉','猪蹄']
x.append('猪头')
print(x)

[‘鸡腿’, ‘红烧肉’, ‘梅菜扣肉’, ‘猪蹄’, ‘猪头’]

注意append不能用于输出函数：print(x.append(”猪头"))
这样输出None

字符串（String）

字符串也可以保存批量数据，只不过其中的数据项只能是字符。
我们在前一个章节中介绍过字符串，字符串是用来表示文本的数据类型。字符串以单引号或双引号以及包裹在其中的若干字符组成
如：’家人‘，“后记”，’3‘，’‘3“，”30.“
字符串索：
从形式上我们不难看出，字符串中的字符也是有先后次序的。字符串是字符的有序序列，所以也具有索引。也可以根据索引取出其中某一个字符。其索引使用方式和列表相同：

c='kgkgkgkgkgkg'
print(c[5])    #“这是一个字符串索引的是字符串的字符”
c=['gg','kjk','hkhk','hhy']      #“这是个列表索引的是元素”
print(c[2])

g
hkhk

有一点需要注意，字符串不能像列表那样通过索引去改变数据项的值。因为字符串类型的值是不可变的（Immutable），我们不能在原地修改它其中的某个字符。

c='kgkgkgk'
c[0]='glg'
print(c)

Traceback (most recent call last):
File “D:/PycharmProjects/111/take down.py”, line 10, in
c[0]=‘glg’
TypeError: ‘str’ object does not support item assignment

上面报出一个 TypeError 错误，具体信息为「‘str’ object does not support item assignment」，其中「‘str’ object」指的就是字符串，它不支持直接为其中某一个项（字符）赋值。
但列表可以:

c=['gg','kjk','hkhk','hhy']
c[0]='klfk'
print(c)

[‘klfk’, ‘kjk’, ‘hkhk’, ‘hhy’]

title（）函数

title()函数是把字符或字符串首字母大写

qiang='max'
print(qiang.title())

Max

title函数字符串中有空格，则会把空格后面的字符或字符串首字母大写。

qiang= "ada  lovelace"
print(qiang.title())

Ada Lovelace

函数title() 不需要额外的信息，因此它后面的括号是空的。

upper()函数

是把字符串或字符中的字符字母全部大写

qiang= "ada  lovelace"
print(qiang.upper())

ADA LOVELACE

lower()函数

是把字符或字符串的字符字母全部小写。

qiang= "ABa  LovelacE"
print(qiang.lower())

aba lovelace

存储数据时，方法lower() 很有用。很多时候，你无法依靠用户来提供正确的大小写，因此需要将字符串先转换为小写，再存储它们。以后需要显示这些信息时，再将其转换为最合适的大小写方式。

字符串长度

字符串中字符的个数也就是字符串的长度（包括空格在内的所有空白符号）。
获取字符串长度的方式和列表一样，也是使用 len()：

c='kfgkfgkgkkltlkrlkrklfrk     '
print(len(c))
n='f'
print(len(n))

28
1

** 合并（拼接）字符串**

变量 + “ ” +变量

first_name='xiao'
last_name='qiangqiang'
name=first_name + ' '+ last_name
print(name.title())
print("Hello, " + name.title() +" come phyton world." )

Xiao Qiangqiang
Hello, Xiao Qiangqiang come phyton world.

使用制表符或换行符来添加空白*

在编程中，空白 泛指任何非打印字符，如空格、制表符和换行符。你可使用空白来组织输出，以使其更易读。
制表符：（\t） t取的是table之意。它的含义是一个字符，叫做制表符。它的作用是对齐表格数据的各列。运行以下代码，你应该明白何为制表符。

mane="\t我爱吃鸡腿"
print(mane)

我爱吃鸡腿

换行符

：(\n）意义是换行
注意制表符与换行符可以同时用如果先\t\n是先制表符后换行，如果先\n\t先换行后制表符

mane="\t我爱吃鸡腿\n\t我爱吃清蒸鱼\n\t吃天下美味。"
print(mane)

我爱吃鸡腿
我爱吃清蒸鱼
吃天下美味

删除空白*

确保字符串末尾没有空白，可使用方法rstrip() 。

MAN="JQKA  "
print(MAN)
print(MAN[0].rstrip())

[’ JQKA ']
JQKA

lstrip()函数剔除字符串开头的空白：
strip()函数剔除字符串两端的空白：

MAN=["  JQKA  "]
print(MAN)
print(MAN[0].rstrip())			#MAN[0]是MAN列表的第一个元素
print(MAN[0].lstrip())
print(MAN[0].strip())
print(MAN)

[’ JQKA ']

JQKA
JQKA
JQKA
[’ JQKA ']

注意e 调用函数rstrip() \函数lstrip\函数strip后，这个多余的空格被删除了。然而这种删除只是暂时的，接下来再次询问变量 的值时，你会发现这个字符串与输入时一样，依然包含多余的空白。
要永久删除这个字符串中的空白，必须将删除操作的结果存回到变量中：

MAN=['  JQKA ']
MA=MAN[0].strip()
print(MA)

JQKA

注意；三个剔除空白的函数只能对单个字符串，不可以对列表

**三大函数：input()、print() 和 int() 函数

**
很多时候程序的功能会比较复杂，单一的执行流程并无法满足要求，程序在运行时可能需要对一些条件作出判断，然后选择执行不同的流程。这时就需要分支和循环语句了。
在开始学习分支和循环前，为了可以让程序与我们交互，先来学习三个函数。至于什么是函数，我们暂且把它看作是程序中具有某种功能的组件，下一小节中将会详细介绍函数的概念。

input() 函数

如果想要通过命令行与程序交互，可以使用 input() 函数。

input() 函数可以在代码执行到此处时输出显示一段提示文本，然后等待我们的输入。在输入内容并按下回车键后，程序将读取输入内容并继续向下执行。读取到的输入内容可赋值给变量，供后续使用。写法如下：

读取到的输入 = input(‘提示文本’)

age=input(‘请输入你年龄：’)
print(age)

请输入你年龄：66
66

这行代码会在命令行中显示「请输入你的年龄：」，然后等待输入，读取到输入内容后赋值给 age 变量。
然后输出
int是把字符型和浮点型转变成整形
int（）参数必须是字符串、类似字节的对象或数字

I=['55','5.1']
print(I)
C=int(I[0])        #不可以C=int(I）因为这样int变换的是列表会报错
print(C)
print(I[1])           #也可以换成print(I[0]）

[‘55’,‘5.1’]
55
5

将浮点数 3.14 转化为整数：

C=3.14
print(int(C))

3

函数str()

函数str()表示把非字符串表示为字符串

age=18
n='Hello '+ str(age)+" welcome to adult !"
print(n)

Hello 18 welcome to adult !

如果不加函数str不报错。报错原因是函数print不能输出这样的字符串：

print('Hello ' + age +"welcom to adult ！"）

会报错
注释（让自己和别人更明白自己写的程序内容）两种表示方法
1“#
2：六个引号

m="Hello ,wlcome to phyton world!"      #你好，欢迎来到phyton世界.
"""你好，欢迎来到phyton世界."""
print(m)

Hello ,wlcome to phyton worl

print() 函数

print() 函数可以将指定的内容输出到命令行中。写法如下：

print(‘要输出的内容’)可以是单引号也可以双引号

print('hiall,i likew eat meal')
print('你好，我喜欢吃肉')

hiall,i likew eat meal
你好，我喜欢吃肉

print与input两个函数可以同时使用

n=input("你的姓名:")
q=input("你的年龄")
d=n+"\n"  +  q
print(d)

你的姓名:xiaoqiangqiang
你的年龄24
xiaoqiangqiang
24

扩展：单引号，双引号，三引号的区别 单撇号，双撇号区别：

i='phyton'
b="phyton"
v='her's apple.'
e='her\'s apple.'    #\转义字符
a="her's apple."
t='We all know that \'A\' and \'B\' are two capital letters.'   #复杂
n="We all know that 'A' and 'B' are two capital letters."
"""如果字符串中有双引号，
为了避免使用转义符，
你可以使用单引号来定义这个字符串
"""""
m='The teacher said: "Practice makes perfect" is a very famous proverb.'
print(i)
print(b)
''''''''''
print(m)

phyton
phyton
her’s apple.
her’s apple.
her’s apple.
We all know that ‘A’ and ‘B’ are two capital letters.
We all know that ‘A’ and ‘B’ are two capital letters.

这就是Python易用性和人性化的一个极致体现，当你用单引号’ '定义字符串的时候，它就会认为你字符串里面的双引号" "是普通字符，从而不需要转义。反之当你用双引号定义字符串的时候，就会认为你字符串里面的单引号是普通字符无需转义
3个单引号及3个双引号
实际上3个单引号和3个双引号不经常用，但是在某些特殊格式的字符串下却有大用处。通常情况下我们用单引号或者双引号定义一个字符串的时候只能把字符串连在一起写成一行，如果非要写成多行，就得在每一行后面加一个\表示连字符，比

str1 = "List of name:\
        Hua Li\
        Chao Deng"

print(str1)

而且即使你这样写也不能得到期望的输出：

List of name:
Hua Li
Chao Deng

实际上输出是下面这样的：

List of name: Hua Li Chao Deng

那么该如何得到我们期望的一行一个名字的输出格式呢？这就是3个引号的作用了：

 str1 = """List of name:
... Hua Li
... Chao Deng
... """
 print(str1)

List of name:
Hua Li
Chao Deng

虽然我们也可以通过给字符串加上\n实现：

 str1 = "List of name:\nHua Li\nChao Deng"
 print(str1)

List of name:
Hua Li
Chao Deng

但是这样在输入的时候看起来就乱了很多不是么？所以这种情况下尽量使用3个引号，至于3个单引号还是双引号都是一样的，只需要注意如果字符串中包含有单引号就要使用双引号来定义就好了。

而且使用3个引号还有一个特别棒的作用就是：加注释！

"""你好，我爱phyton"""

if语句

如果想要表达「如果……」或者「当……」这种情形，需要用到 if 语句。它的写法是：

if 条件:
	 代码块
elif 条件: 
 	代码块
else 条件:
	代码块

它的执行规则是，若if「条件」满足，则执行 if 下的「代码块」，若「条件」不满足则不执行。然后判断elif【条件】是否满足如果满足执行elif的【代码块】，如果elif【条件】不满足，则执行else，判断else的【条件】是否满足。如果满足这执行else的【代码块】。若不满足则跳出if语句。最后输出空白。

条件满足指的是，条件的结果为布尔值 True，或非零数字，或非空字符串，或非空列表。
代码块就是一段代码（可以是一行或多行），这段代码作为一个整体以缩进的形式嵌套在 if 下面。按照通常的规范，缩进以 4 个空格表示。

>name=input("请输入你名字：")
age=int(input("请输入你的年龄："))input定义是字符型，int把字符型转换成整形
if age>=18:
    print(name +"你好，你已经成年。")
else:
    print(name +"你好，你还是青年." )

请输入你名字：小强强
请输入你的年龄：20
小强强你好，你已经成年。

注意：条件语句区分大小写。

MA=["Car","cat","cell","DAG"]
for m in MA :
    if m=="car":
        print("红烧肉")
    else:
        print("鸡腿")

鸡腿
鸡腿
鸡腿
鸡腿

所以这时需要调用三个函数
title——字符串或字符的首字母改为大写。
upper——字符串或字符全部改为大写。
lower——字符串或字符全部改为小写。

MA=["Car","cat","cell","DAG"]
for m in MA :
    if m.lower()=="car":
        print("红烧肉")
    else:
        print("鸡腿")

红烧肉
鸡腿
鸡腿
鸡腿

MA=["Car","cat","cell","DAG"]
for m in MA :
    if m.lower()!="car":			#!= |表示不等于。
        print("红烧肉")
    else:
        print("鸡腿")

鸡腿
红烧肉
红烧肉
红烧肉

if b变量 in a变量：表示b变量是否在变量a中，如果在则if 表达 ture，不在false

MA=["Car","cat","cell","DAG"]
li=["cell","dag"]
for m in MA :
    for l in li:
        if l in m.lower():
            print("红烧肉")
        else:
            print("鸡腿")

鸡腿
鸡腿
鸡腿
鸡腿
红烧肉
鸡腿
鸡腿
红烧肉

elif 语句

我们可以看到，if 和 else 表达的是「如果……否则……」这样的二元对立的条件，非此即彼。但有时我们还需要表达「如果……或者……或者……否则……」这样多个条件间的选择。
举个例子，下表是年龄和其对应的人生阶段。
年龄 人生阶段
0-6 岁 童年
7-17 岁 少年
18-40 岁 青年
41-65 岁 中年
65 岁之后 老年
当我们在程序中输入一个年龄时，输出对应的人生阶段。该如何实现？我们先用汉语来描述一下代码逻辑（这种自然语言描述的代码逻辑，也叫作伪代码）：

>如果年龄小于等于 6:
    输出童年
如果年龄介于 7 到 17:
    输出少年
如果年龄介于 18 到 40:
    输出青年
如果年龄介于 41 到 65:
    输出中年
否则:
    输出老年 

请输入年龄：3
童年
请输入年龄：17
少年
请输入年龄：30
青年
请输入年龄：65
中年
请输入年龄：100
老年

可以看到，我们需要依次进行多个条件判断。要实现它就要用到 elif 语句了，字面上它是 else if 的简写。

elif 置于 if 和 else 之间，可以有任意个：

if 条件 1:
    代码块 1
elif 条件 2:
    代码块 2
else 条件:
    代码块 3    

分支语句小结

如上所述，if 可以配合 elif 和 else 一起使用。代码执行时，将会从第一个条件开始依次验证判断，若其中某个条件满足，则执行对应的代码块，此时后续条件将直接跳过不再验证。

一个 if-elif-else 组合中，elif 可出现任意次数，else 可出现 0 或 1 次。

while 循环

之前介绍的 if 语句，是根据条件来选择执行还是不执行代码块。我们还有一种很重要的场景——根据条件来判断代码块该不该被重复执行，也就是循环。

在 Python 中可以使用 while 语句来执行循环操作，写法如下：

while 条件:
    代码块

它的执行流程是，从 while 条件这句出发，判断条件是否满足，若满足则执行代码块，然后再次回到 while 条件，判断条件是否满足……循环往复，直到条件不满足。

可以看到，如果这里的条件一直满足且固定不变，那么循环将无穷无尽地执行下去，这称之为死循环。一般情况下我们很少会刻意使用死循环，更多的是让条件处于变化中，在循环的某一时刻条件不被满足然后退出循环。
循环示例

n=0
while n<=5:
    n=n+1
    print(n)

1
2
3
4
5
6
7

扩展：count = count + 1 可以简写为 count += 1

条件的与、或、取反(或与非）

and
and要表达多个条件同时满足的情况，可以使用 and 关键字。使用 and 关键字时，在所有并列的条件均满足的情况下结果为 True。至少一个条件不满足时结果为 False。
条件语句：

if [条件一 and 条件二and 条件三and~~~~~~~条件n]:
	代码块

只有在所有的条件均满足的情况下，代码块才会被执行。
or
要表达多个条件中至少一个满足即可的情况，可以使用 or 关键字。使用 or 关键字时，并列的条件中至少有一个满足时，结果为 True。全部不满足时结果为 False。

if [条件语句：条件1 or 条件2 or~~~~~~ 条件N]:
	代码块

只要有任意一个（或多个）条件满足，代码块就会被执行。
not(!)
not 关键字可以将一个布尔值取反
not(!) Ture =False
not(!) False =Ture

if 条件：not(!)条件：
代码块

条件不满足时执行代码块，条件满足时反而不执行，因为 not 关键字对结果取了反。

for循环

for 循环更多的是用于从头到尾地去扫描列表、元组这类数据结构中的每一个项，这种方式叫做遍历或迭代。
for 循环写法为：

for 项 in 序列:
	代码块

其执行过程是，反复执行 for 项 in 序列 语句和其代码块，项 的值依次用序列的各个数据项替换，直到序列的所有项被遍历一遍。

ainmals=['dog','cat','pag','monkey','Panda','Duck',]
for ainmal in ainmals:
    print(ainmal)
    print("Do you like；"+ainmal+ "?")
print("These ainmals are very healthy.")

cat
Do you like；cat?
pag
Do you like；pag?
monkey
Do you like；monkey?
Panda
Do you like；Panda?
Duck
Do you like；Duck?
These ainmals are very healthy.

每次循环时 项都自动被赋予新的值，直到所有列表元素遍历完，循环退出。`

避免缩进错误

忘记缩进
对于位于for 语句后面且属于循环组成部分的代码行，一定要缩进。如果你忘记缩进，Python会提醒你：提醒的形式报错

magicians = ['alice', 'david', 'carolina']
for magician in magicians: 
print(magician)

print 语句应缩进却没有缩进。Python没有找到期望缩进的代码块时，会让你知道哪行代码有问题。

File “magicians.py”, line 3
print(magician)
^
IndentationError: expected an indented block

通常，将紧跟在for 语句后面的代码行缩进，可消除这种缩进错误。

忘记缩进额外的代码行

有时候，循环能够运行而不会报告错误，但结果可能会出乎意料。试图在循环中执行多项任务，却忘记缩进其中的一些代码行时，就会出现这种情况。
这是缩进正确的。

wanwu=['糖糕',"胡辣汤","八宝粥","油条","包子"]
for wanw in wanwu:
    print(wanw)
    if wanw =="糖糕":
        print("\n你喜欢吃糖糕。\n")
print("我喜欢吃点其他的")
    else:
        print("")
        # print("我喜欢吃点其他的")

糖糕
我不喜欢吃糖糕。
我喜欢吃点其他的
我喜欢吃点其他的
胡辣汤
八宝粥
油条
包子

这是缩进错误的`

wanwu=['糖糕',"胡辣汤","八宝粥","油条","包子"]
for wanw in wanwu:
    print(wanw)
    if wanw =="糖糕":
        print("\n我不喜欢吃糖糕。\n")
    # print("我喜欢吃点其他的")
    else:
        print("")
        print("我喜欢吃点其他的")

糖糕
你喜欢吃糖糕吗
胡辣汤
我喜欢吃点其他的
八宝粥
我喜欢吃点其他的
油条
我喜欢吃点其他的
包子
我喜欢吃点其他的

缩进错误的，照成第九行代码每循环一次就执行一次。

注意：for循环后面必须加冒号。

创建数值列表

使用函数range(),函数range() 让你能够轻松地生成一系列的数字。

for shuzi in range(1,6):
    print(shuzi)

1
2
3
4
5

上述代码好像应该打印数字1~6，但实际上它不会打印数字6,range() 只是打印数字1~5，这是你在编程语言中经常看到的差一行为的结果。函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值
后停止，因此输出不包含第二个值（这里为6)。
使用函数range() 时，如果输出不符合预期，请尝试将指定的值加1或减1。

使用range() 创建数字列表

要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。如果将range() 作为list() 的参数，输出将为一个数字列表在前一节的示例中，我们打印了一系列数字。要将这些数字转换为一个列表，可使用list()

number=list(range(1,6))
print(number)

[1, 2, 3, 4, 5]

使用函数range() 时,还可以制作特定的数字列表。如可以制作2—10的偶数
1—10的奇数，以及可以被三除尽的数，等等
制作2—10的偶数列表

number=list(range(2,10,2))
print(number)

[2, 4, 6, 8]

制作1—10的奇数列表。

number=list(range(1,10,2))
print(number)

[1, 3, 5, 7, 9]

制作1—10可以被三整除的

number=list(range(3,10,3))
print(number)

[3, 6, 9]

在这些示例中

函数range（x数开始，y结束但不包括y，z是x每次加z到y结束)
因此输出如上。

知道这些就可以使用函数range() 几乎能够创建任何需要的数字集，例如，如何创建一个列表，其中包含前10个整数（即1~10）的平方

numbers=[]
for numberg in range(1,10):
    numberu=numberg**2
    numbers.append(numberu)
print(numbers)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

调用append的函数，
append()方法用于在列表末尾添加新的对象。
append()方法语法：list.append(obj)

可以添加列表，字典，元组，集合，字符串等

对数字列表执行简单的统计计算

有几个专门用于处理数字列表的函数。例如，你可以轻松地找出数字列表的最大值、最小值和总和：

number=[1,50,20,888,56,22,13,]
print(min(number))
print(max(number))
print(sum(number))

1
888
1050

处理列表的函数

min列表最小值
max列表的最大值
sum列表求和

切片 使用列表的一部分——处理列表的部分元素

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数range() 一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0 、1 和2 的元素。

lunch=["米饭","面条","小炒","米线","炒粉","麻辣烫"]
N=lunch[1:4]
print(N)
print(lunch[1:1])
print(lunch[0:5])
print(lunch[ : ])
print(lunch[0:7])
print(lunch[0:-1])
print(lunch[-3: ])

[‘面条’, ‘小炒’, ‘米线’]
[]
[‘米饭’, ‘面条’, ‘小炒’, ‘米线’, ‘炒粉’]
[‘米饭’, ‘面条’, ‘小炒’, ‘米线’, ‘炒粉’, ‘麻辣烫’]
[‘米饭’, ‘面条’, ‘小炒’, ‘米线’, ‘炒粉’, ‘麻辣烫’]
[‘米饭’, ‘面条’, ‘小炒’, ‘米线’, ‘炒粉’]
[‘米线’, ‘炒粉’, ‘麻辣烫’]

切片与前面的索引有很大的相同，前面的索引是寻找列表的单个元素。而切片是寻找一部分元素，但不可以是单个元素。

切片：变量[ : ]可以填任何数，填的数字不同，输出结果也不同。但两个数不可以相同。

切片与for循环联系在一起

lunch=["米饭","面条","小炒","米线","炒粉","麻辣烫"]
for n in lunch[0:5]:
    if n=="小炒":
        print("我不喜欢吃的： "+n)
    else:
        print(n)
print("这些都是我喜欢吃的中午饭：" )

米饭
面条
我不喜欢吃的： 小炒
米线
炒粉
这些都是我喜欢吃的中午饭

元组(tuple）

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组 。

定义元组
元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

lunch=("米饭","面条","小炒","米线","炒粉","麻辣烫")
for n in lunch[0:5]:
    if n=="小炒":
        print("我不喜欢吃的： "+n)
    else:
        print(n)
print("这些都是我喜欢吃的中午饭：" )

米饭
面条
我不喜欢吃的： 小炒
米线
炒粉
这些都是我喜欢吃的中午饭：

元组与列表最大的区别是：列表可以修改列表的元素，但是元组不可以。

lunch=("米饭","面条","小炒","米线","炒粉","麻辣烫")
lunch[0]="粥"
print(lunch)

TypeError: ‘tuple’ object does not support item assignment
TypeError:“tuple”对象不支持项分配

元组也可以像列表一样使用for循环如上第二行代码。

如果要修改元组里的变量需要重新定义元组。

注意元组括号里面只要一个元素就必须加上逗号。

字典

在Python中，字典 是一系列键—值对 。每个键 都与一个值相关联，你可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将
任何Python对象用作字典中的值。
在Python中，字典用放在花括号{} 中的一系列键—值对表示，如前面的示例所示：

shorts={'colour':'red','big or small':'big'}

键—值 对是两个相关联的值。指定键时，Python将返回与之相关联的值。 键和值可以用单引号或双引号，键和值之间用冒号分隔，而键—值对之间用逗号分隔。在字典中，你想存储多少个键—值对都可以。

访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的键，如下所示

shorts={'colour':'red','big or small':'big'}
print(shorts['colour'])

red

字典是动态结构可以跟列表一样进行相应的操作。

添加键—值对

字典是一种动态结构，可随时在其中添加键—值对。要添加键—值对，可依次指定字典名、用方括号括起的键和相关联的值。

shorts={'colour':'red','big or small':'big'}
print(shorts['colour'])
shorts['pattern']='pig'
print(shorts)

red
{‘colour’: ‘red’, ‘big or small’: ‘big’, ‘pattern’: ‘pig’}

** 修改字典中的值**

先创建一个空字典
之后再往字典添加键值。修改字典中的值
要修改字典中的值，可依次指定字典名、用方括号括起的键以及与该键相关联的新值。

shorts={'colour':'red','big or small':'big'}
print(shorts['colour'])
shorts['pattern']='pig'
print(shorts)
shorts['colour']='yellow'
print(shorts['colour'])

red
{‘colour’: ‘red’, ‘big or small’: ‘big’, ‘pattern’: ‘pig’}
yellow

删除键—值对

对于字典中不再需要的信息，可使用del 语句将相应的键—值对彻底删除。使用del 语句时，必须指定字典名和要删除的键。

shorts={'colour':'red','big or small':'big'}
print(shorts['colour'])
shorts['pattern']='pig'
print(shorts)
shorts['colour']='yellow'
print(shorts['colour'])
del shorts['big or small']
print(shorts)

red
{‘colour’: ‘red’, ‘big or small’: ‘big’, ‘pattern’: ‘pig’}
yellow
{‘colour’: ‘yellow’, ‘pattern’: ‘pig’}

遍历字典 *遍历所有的键—值对

*借用for循环和函数items

shorts={'colour':'red','big or small':'big'}
# print(shorts['colour'])
shorts['pattern']='pig'
for key, value in shorts.items():
    print("key:" +key)
    print("v:" +value)

key:colour
v:red
key:big or small
v:big
key:pattern
v:pig

遍历字典中的所有键

在不需要使用字典中的值时，方法keys() 很有用。

shorts={'colour':'red','big or small':'big'}
# print(shorts['colour'])
shorts['pattern']='pig'
for key in shorts.keys():		#for key in shorts：
    print("key: "+key)

key: colour
key: big or small
key: pattern

遍历字典时，会默认遍历所有的键，因此，如果将上述代码中的for key in shorts.keys(): 替换为for key in shorts: ，输出
将不变。
如果显式地使用方法keys() 可让代码更容易理解，你可以选择这样做，但如果你愿意，也可省略它。

按顺序遍历字典中的所有键

字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的。这不是问题，因为通常你想要的只是获取与键相关联的正确的值。
要以特定的顺序返回元素，一种办法是在for 循环中对返回的键进行排序。为此，可使用函数sorted() 来获得按特定顺序排列的键列表的副本

shorts={'colour':'red','big or small':'big'}
# print(shorts['colour'])
shorts['pattern']='pig'
for key in sorted(shorts.keys()):
    print("key: "+key)
for key in shorts:
    print(key)

key: big or small排序的键
key: colour
key: pattern
colour未排序的建
big or small
pattern

** 遍历字典中的所有值**

可使用方法values() ，遍历字典所有的值，它返回一个值列表，而不包含任何键

shorts={'colour':'red','big or small':'big'}
# print(shorts['colour'])
shorts['pattern']='pig'
for value in shorts.values():
    print(value)

red
big
pig

set函数

但是当字典的值有重复的，当想剔除重复的需要调用函数set

shorts={'colour':'red','big or small':'big','pattern':'red','big':'big'}
for value in set(shorts.values()):
    print(value)
print("\n")
for value in shorts.values():
    print(value)

red
big
当没有set函数时
red
big
red
big

嵌套 字典列表

列表中含有字典

shorts={'colour':'red','big or small':'big','pattern':'red','big':'big'}
T_short={'colour':'yellow','big or smell':'smell','pattern':'pig'}
clothes=[shorts,T_short]
print(clothes[0])

{‘colour’: ‘red’, ‘big or small’: ‘big’, ‘pattern’: ‘red’, ‘big’: ‘big’}

利用for循环可以制造多个储存在列表的字典。

T_shorts=[]
for T in range(1,20):
    T_short = {'colour': 'yellow', 'big or smell': 'smell', 'pattern': 'pig'}
    T_shorts.append(T_short)
for t_shorts in T_shorts[:5]:
    print(t_shorts)
print("....")
print("输出19个T恤")

{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
…
输出19个T恤

改变字典的值

T_shorts={'colour':'yellow'}
T_shorts['colour']='red'
print(T_shorts)

red

或

T_shorts=[]
for T in range(1,20):
    T_short = {'colour': 'yellow', 'big or smell': 'smell', 'pattern': 'pig'}
    T_shorts.append(T_short)
for t_shorts in T_shorts[:5]:
    if t_shorts['colour']=='yellow':
        t_shorts['colour']='red'
        t_shorts['big or smell']='big'
        t_shorts['pattern']='dag'
for t_shorts in T_shorts[:10]:
    print(t_shorts)

{‘colour’: ‘red’, ‘big or smell’: ‘big’, ‘pattern’: ‘dag’}
{‘colour’: ‘red’, ‘big or smell’: ‘big’, ‘pattern’: ‘dag’}
{‘colour’: ‘red’, ‘big or smell’: ‘big’, ‘pattern’: ‘dag’}
{‘colour’: ‘red’, ‘big or smell’: ‘big’, ‘pattern’: ‘dag’}
{‘colour’: ‘red’, ‘big or smell’: ‘big’, ‘pattern’: ‘dag’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}
{‘colour’: ‘yellow’, ‘big or smell’: ‘smell’, ‘pattern’: ‘pig’}

*在字典中存储列表

在字典中有列表。

T_short = {'colour': ['yellow'],  'pattern': ['pag','egg','dag','jika']}
print(T_short)
colours=['red','green','white']
T_short['colour'].append(colours)
print(T_short)

{‘colour’: [‘yellow’], ‘pattern’: [‘pag’, ‘egg’, ‘dag’, ‘jika’]}
{‘colour’: [‘yellow’, [‘red’, ‘green’, ‘white’]], ‘pattern’: [‘pag’, ‘egg’, ‘dag’, ‘jika’]}

注意 列表和字典的嵌套层级不应太多。如果嵌套层级比前面的示例多得多，很可能有更简单的解决问题的方案。

在字典中存储字典

储存个人信息

peoples={'xiaoming':
             {'address':'China',
                'sex':'man',
                'cell_phone':'112'},
        'xiaohong':
            {'address':'English',
            'sex':'woman',
            'cell_phone':'110'}
        }
print(peoples)

{‘xiaoming’: {‘address’: ‘China’, ‘sex’: ‘man’, ‘cell_phone’: ‘112’}, ‘xiaohong’: {‘address’: ‘English’, ‘sex’: ‘woman’, ‘cell_phone’: ‘110’}}