1. 运行Python程序的两种方式
2. 运行Python程序的三步骤（与文本编辑器对比）
3. IDE工具----pycharm
4. 注释
5. 变量
6. 基本数据类型及其内置方法
7. 垃圾回收（GC）机制
8. 基本运算符
9. 流程控制（if、while、for）

小白学习，如有错误欢迎指点

一、每位小白写的第一个Python程序

1.运行Python程序的两种方式

1.1 交互式模式（即时对话）

打开cmd，打开Python解释器

输入 print("hello world")

回车直接显示 hello world

（交互式能够及时得到代码执行结果，调试程序十分方便，但无法保存代码）

1.2 脚本文件的方式（约定此类文件后缀为.py，虽然没有后缀也没事）

打开一个文本编辑器，写入 print("hello world") 这段代码并保存至D:test.py

打开cmd，直接输入 python D:test.py #python+文件路径

回车显示 hello world （即运行结果）

（代码可以永久保存，以后开发程序主要都是将代码写入文件即使用脚本的方式，偶尔打开交互式模式调试其中某一段代码验证结果）

2.运行Python程序的三步骤

• 启动python解释器
• 解释器发送系统调用，将已写好的代码文件内容读入至内存（此时文件内的字符没有任何语法意义，只是一些普通字符）
• 解释器读取刚刚读入内存的内容，并识别python语法并执行

对比文本编辑器读取代码文件的步骤

• 启动文本编辑器
• 文本编辑器发送系统调用，将已写好的代码文件内容读入至内存
• 文本编辑器读取刚刚读入内存的内容，将内容输出到屏幕上，让用户看到结果

总结：其实python解释器也是一种程序，所以两者的前两个步骤完全相同，只有在第三步对读取的代码的处理方式不同即仅仅每个程序最后所实现的功能不同而已。

二、IDE工具（集成开发环境）——pycharm

IDE的意义：IDE(Integrated Development Environment)顾名思义，就是集合了开发所需的一切工具构成一个整体的开发环境（如代码提示，代码补全，代码纠错，及时保存文件等等功能），拥有IDE工具后能够极大提升程序员的开发效率，目前开发python程序最好的IDE就是pycharm

pycharm安装：一般使用专业版，所含功能更多

官方下载地址：https://www.jetbrains.com/pycharm/download

虚拟环境：

虚拟环境就相当于初始真实环境的复制体，每开发一个新项目，我们都应该建立一个虚拟环境，以供下载安装第三方的库，当项目结束之后就可以将虚拟环境删掉，重新建立新的环境，避免对下一个开发项目造成污染影响。

三、python语法（语法就是规则、原则）

每一个语法其实都是在模仿取代人类的某项能力，所以学习语法的方法：

三步走：是什么，为什么，怎么用(what、why、how)

1.注释

what：

注释就是对代码的解释说明，注释部分不会被当做代码执行

why：

增强代码的可读性（模仿人的解释说明的能力），可以注释掉不想运行的代码

how：

注释分为单行注释和多行注释

单行注释用#，可写在代码正上方或者正后方

多行注释用三对双引号或单引号，分别放在代码正上方和正下方（多行注释一般只在代码开头写一次）

# 注释不要用拼音，只标记关键代码，不用全文注释

2.变量（标识符的一种）

what：

变量是指变化的量，量即事物的状态（如游戏角色的等级，性别，金钱）

why：

程序运行的本质是一系列状态的变化，需要一种机制能够保存记录事物的状态，而事物的状态是不断发生变化的（模仿人的记忆事物的能力），变量其实就是存取内存的机制

how：先定义，后引用（先存后取）

定义变量：

变量名=变量值（解释器执行变量定义时，会申请内存空间存放变量值，存放地址绑定给变量名，这样就可以通过变量名获取相应变量值）

# 可以同时为多个变量赋值 如： a,b = 1,2

命名规范：

• 见名知意
• 变量名只能是字母（包括中文等语言字符）、数字、下划线的组合（尽量不要使用中文）
• 第一个字符不能是数字
• 关键字不能被定义成变量名，但可以被包含（如and、as、def、if、for、while、is、not、else、or等等）
• python中变量名一般使用纯小写下划线风格，一般空格可以用“_”下划线替代（如age_of_lili=56）

#驼峰体是变量名的每个单词首字母大写

补充：del 变量名 表示解除变量名与变量值的绑定关系 （垃圾回收引用计数减少）

变量的三大特性

• id：变量的内存地址，每个变量都有唯一编号 # 查看id的方式 print（id（变量名））
• type：变量值的类型（如str，int，float等） # 查看type的方式 print（type（变量名））
• value：变量值 # 查看值的方式 print（变量名）

#两个等号“==”比较的仅仅是value值，“is”比较的是id（出于对性能的优化，所以不同的变量，当变量值相同时，id也可能相同，如变量值是在小整数池内的变量，这是一种内存优化机制）

常量（python中没有常量的说法或规范）

与变量相对即程序运行时，固定不变的值（量），在python中用法和变量一样，只是常量一般约定变量名全部用大写表示（如PI=3.1415926），但本质上变量值还是可以修改的

# 与python不同，C语言中有专门的语法定义常量且一旦定义为常量，再变更就会报错

3.基本数据类型

有了变量后，我们就可以记录事物的状态，但事物的状态有不同种类（年龄，性别，身高，名字等），所以变量值也有不同的类型

type(变量名)：可查询对应变量值的数据类型

每一种数据类型内置了一系列方法，掌握常见方法的使用

3.1 数字类型：（不可变类型）

• int整型：用于标识年龄，等级，QQ号，身份证号码等等整数类的变量，如：age=10，相当于age=int("10")，int函数可以把纯数字的其他类型数据转化为整型数据
• float浮点型：用于标识身高，体重等存在小数的变量，如 salary=3.2，相当于salary=float(3.2)，float函数可将小数的其他类型数据转化为浮点型数据
• complex复数型：如x=1+2j

进制转换（）

# 十进制转其他进制
>>> bin(3) # 二进制
'0b11'
>>> oct(9) # 八进制
'0o11'
>>> hex(17) # 十六进制
'0x11'
# 其他进制转十进制
>>> int('0b11',2) # 二进制
3
>>> int('0o11',8) # 八进制
9
>>> int('0x11',16) # 十六进制
17

3.2 str字符串类型：（不可变类型）

用于记录姓名，国籍，住址等描述性变量，用单引号，双引号，多引号都可以定义字符串，但是要考虑引号嵌套配对问题。如：name=“lili”，多引号可以写多行字符串 ，三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符

# 嵌套使用：字符串中想加引号，应该外层双引号，内层单引号使用

如：print(“ name is 'lili' ”)或者 print(' name is 'lili' ')

(其中“”有转义的意思，表示后边的引号不再有特殊意义，就是普通字符而已，不能用在{}内)（使用r或R也可以让反斜杠不发生转义，r是raw原始的意思，常用r）

str()可以将任意数据类型转换成字符串类型

# 字符串之间可以互相相加，相乘运算（都只是字符串拼接）

字符串核心用法：

①按索引取值（只能取值不能改值）

• str1[6] # 正数代表正向取(从左往右)
• str1[-4] # 负数代表反向取(从右往左)

②切片提取字符串相应数据 [头索引:尾索引:步长]（字符串索引只能取值不能更改值）

• str[1:3] # 获取字符串中索引1~2的字符，不包含3； #str是变量名，顾头不顾尾
• str[:] # 获取字符串中索引0~最后的所有字符；
• str[-3:-1] # 提取字符串中索引（-3）~（-2）的字符，不包含（-1）；
• str[-1:-3] # 提取字符串为空字符串，但系统不提示错误；
• str[::2] # 获取字符串中索引0~最后的所有字符，但步长为2即每两个字符获取一次，如“string”最终获取的是“srn”；如果步长为负数，就是逆向取值

③切分 变量名.split("分隔符") # 这里的分隔符可以是字符串内的任意字符，切分后是list数据类型（不指定分隔符就默认为空格），切割结果以列表数据类型存放

④移除字符串两边空白(空格)：变量名.strip() # 括号内不填写默认移除空格、n、t，填写其他的字符就移除指定字符，注意只能移除字符串两边的，中间的不行

⑤长度len：len(str1) # 获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符（包括空格）

⑥in和not in # 判断字符或字符串是否在或不在目标字符串中（返回布尔值）

⑦可配合for循环使用，依次取出字符串中每一个字符，如：for i in str1:

字符串重要用法：

①strip, lstrip, rstrip

str1.strip('*')  # 移除左右两边的指定字符
str1.lstrip('*')  # 只移除左边的指定字符
str1.rstrip('*')  # 只移除右边的指定字符

②lower,upper

str1.lower()  # 将英文字符串全部变小写
str1.upper()  # 将英文字符串全部变大写

③startswith,endswith

str1.startswith('t')   # startswith()判断字符串是否以括号内指定的字符开头
str1.endswith('j')     # endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False

④split,rsplit

str1.split(':',1)   # split会按照从左到右的顺序对字符串进行切分，可以指定切割次数
str1.rsplit('/',1)  # rsplit刚好与split相反，从右往左切割，可以指定切割次数

⑤join

# 从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串
>>> '*'.join(['tony','18','read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
'tony*18*read'

⑥replace

# 用新的字符替换字符串中旧的字符
str1 = str1.replace('18', '73')   # 语法是str.replace('旧内容', '新内容')
str1 = str1.replace('my', 'MY',1) # 可以指定修改的个数

⑦isdigit

str1.isdigit()  # 判断字符串是否是纯数字组成，返回结果为True或False

⑧capitalize,swapcase,title

str.capitalize()  # 把字符串的第一个字符大写
message1.swapcase() # 字符串中大小写翻转
msg.title() # 字符串中每个单词的首字母大写

了解用法：

①find,rfind,index,rindex,count

find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
str.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引
index:同find,但在找不到时会报错
str.index('e',2,4)
count:统计字符串在大字符串中出现的次数
str.count('e')，msg.count('e',1,6) # 字符串e在索引1~5范围内出现的次数

②center,ljust,rjust,zfill

str.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
str.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
str.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
str.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充

③expandtabs

name = 'tonythello'  # t表示制表符(tab键)，通常有4个空格
name.expandtabs(1)  # 修改t制表符代表的空格数

④is数字系列

#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u即默认就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字#isdigit:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit()
False#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal()
True
>>> num3.isdecimal()
False
>>> num4.isdecimal()
False#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric()
True
>>> num3.isnumeric()
True
>>> num4.isnumeric()
True# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False总结:最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景如果要判断中文数字或罗马数字,则需要用到isnumeric

⑤is其他

name.isalnum() #字符串中是否全是数字或字母
name.isalpha() #字符串中是否只包含字母
name.isidentifier() # 判断字符串是否是有效的 Python 标识符，可用来判断变量名是否合法
name.islower()  # 字符串是否是纯小写
name.isupper()  # 字符串是否是纯大写
name.isspace()  # 字符串是否只有空格
name.istitle()  # 字符串中的单词首字母是否都是大写

3.3 list列表：（可变类型）

用于记录多个相同属性的变量值（也可以是不同属性的），方便取用，在[]内用逗号分隔多个任意数据类型。

如 stu_names=['lili','kitty','ming']

列表嵌套：形如 info=[[xx,xx],[x,x]]等等。使用list的原因在于取用信息是按根据位置顺序来取的

类型转换

但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

list('wdad') # 结果：['w', 'd', 'a', 'd']
list([1,2,3]) # 结果：[1, 2, 3]
list({"name":"jason","age":18}) #结果：['name', 'age']
list((1,2,3)) # 结果：[1, 2, 3]
list({1,2,3,4}) # 结果：[1, 2, 3, 4]

列表核心用法：

①索引取值：列表类型是用索引来对应值，从0开始计数，# -1表示列表的最后一个变量值

print(stu_names[1])，执行过后显示  'kitty'

②修改元素：可按照索引修改指定位置的值，但如果索引不存在则报错

my_friends[1] = 'martthow'

③添加元素：不能通过直接增加索引和值来增加元素

l1.append('d') #尾部追加元素
l1.insert(1，'d') #在指定位置(按索引)插入元素，元素插在索引号对应元素的前面
l1.extend(['a','b','c']) #一次性在列表尾部添加多个元素
l1[100]="aaa" #索引不存在，直接报错

④长度len：len(list1)，显示列表长度，也可以理解为列表中的元素总个数

⑤删除元素：

del 变量名[索引号] # 删除指定索引的元素
# pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
res=l.pop() #删除并返回列表最后一个元素
res=l.pop(0) ##删除并返回列表第一个元素
# remove()括号内指名道姓表示要删除哪个元素，没有返回值
res=l.remove("aaa") # 从左往右查找括号内第一个目标元素并删除，res返回值为None

⑥切片与字符串类似（顾头不顾尾）

list1[0:4] #取出索引为0到3的元素，默认步长为1
list1[0:4:2] #第三个参数2代表步长，会从0开始，每次索引号累加一个2取值

⑦成员运算in和not in：用于判断元素是否在列表中存在

⑧reverse()颠倒列表内元素顺序

l = [11,22,33,44]
l.reverse()
print(l)
结果：
[44,33,22,11]

⑨sort()给列表内所有元素排序

# 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否颠倒排序，默认为False
>>> l
[55, 42, 22, 11, 7, 3]

# 补充：字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素。字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大

⑩循环：列表支持for循环遍历其中的值

3.4 dict字典：（可变类型：值可变）

记录多个不同属性的变量值，可以明确表示值的含义，在{}中用逗号分隔多个元素

如 person_info={'name':'lili','age':18,'height':171.4}

字典类型是用key（键）来对应值，key通常都为字符串，如 person_info['age']，执行后显示 18

#注意 成员运算判断字典时默认都是判断key，而不是key后面的元素

字典嵌套：形如 info=[{xx:xx,xx:xx},{x:x,x:x}]等，使用字典的原因在于取用信息是根据具体key即关键词来取的

类型转换

# 转换1:
info=dict([['name','tony'],('age',18)])
或者 info=dict(a=1,b=3)# 转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)
{'age': None, 'sex': None, 'name': None}

字典核心用法：

①按key存取值：可存可取

dic['hobbies'][1] # 按key取值
# 添加元素对于赋值操作，如果key原先不存在于字典，则会新增key:value
# 对于赋值操作，如果key原先存在于字典，则会修改对应value的值

②添加元素：对于赋值操作，如果key原先不存在于字典，则会新增key:value

变量名[key]=值

③修改元素：对于赋值操作，如果key原先存在于字典，则会修改对应value的值

变量名[key]=值

④长度len：显示字典长度，即字典的元素总个数（一个元素包括key和value）

⑤成员运算in和not in：判断某个值是否存在于字典的key

⑥删除元素：

dic.pop(key)  # 通过指定字典的key来删除字典的键值对
del 变量名[key]  # 可以通过del，指定字典的key来删除字典的键值对

⑦键keys()，值values()，键值对items()：分别获得字典中所有的key、值、键值对

>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

⑧循环

1、默认遍历的是字典的key
for key in dic:2、只遍历key
for key in dic.keys():3、只遍历value
for key in dic.values():4、遍历key与value，结果为一个个元组
for key in dic.items():

字典重要用法

①get()：取值

>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.get('k1')
'jason'  # 若key存在，则获取key对应的value值
>>> res=dic.get('xxx') # 若key不存在，不会报错而是默认返回None
>>> print(res)
None
>>> res=dic.get('xxx',666) # 若key不存在时，可以设置默认返回的值，若key存在则返回正确对应的值
>>> print(res)
666
# ps:字典取值建议使用get方法

②pop()：删除指定键值对

v = dic.pop('k2')  # 删除指定的key对应的键值对,并返回值（只返回值，没有key）

③popitem()：随机删除键值对

dic= {'k1':'jason','k2':'Tony','k3':'JY'}
item = dic.popitem()  # 随机删除一组键值对,并将删除的键值对放到元组内返回

④update()：更新字典

# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

⑤fromkeys()：fromkeys会从元组中取出每个值当做key，然后与指定值组成key:value放到字典中

>>> dic = dict.fromkeys(['k1','k2','k3'],[])
>>> dic
{'k1': [], 'k2': [], 'k3': []}

⑥setdefault()：

# 若key不存在则新增键值对，并将新增的value返回
res=dic.setdefault('k3',333)
# 若key存在则不做任何修改，并返回已存在key对应的value值

3.5 bool布尔类型：

用于记录真假两种状态，即True和False

所有数据类型都自带布尔值：None，0，空（空字符串，空列表，空字典等）三种情况布尔值为False(0)，其余均为True(1)

布尔值也可以和数字运算

3.6 tuple元组（不可变类型）

元组内元素不能修改，写在()内，元素间用逗号隔开多个任意类型的值，其余和列表类似

注意：元组内的元素无法修改，指的是元组内索引指向的内存地址不能被修改，但如果元组中存在可变类型，是可以修改，但是修改后的内存地址不变

# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
>>> countries = ("中国"，)  # 本质:countries = tuple("中国")

类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd')
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)

元组的用法：

①按索引取值，注意：只能取，不能改否则报错

tuple1[1] #正向取
tuple1[-2] #反向取
tuple1[0] = 'hehe' # 修改元素直接报错

②切片(顾头不顾尾)

tuple1[0:6:2] # 从0到5，步长为2，依次取值

③长度len：len(tuple1)，显示元组长度，也可以理解为元组中的元素总个数

④in 和 not in：判断元素是否存在于元组

⑤循环：可for循环遍历元组内的值

3.7 set集合（可变类型）

集合和list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

集合是在{}内用逗号分隔开多个元素

集合具备以下三个特点：

• 每个元素必须是不可变类型（数字、字符串、元组）
• 集合内没有重复的元素
• 集合内元素无序

集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系运算，根本没有取出单个指定值这种需求

由于{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，所以当想定义一个空字典和空集合，该如何准确去定义两者：

d = {} # 默认是空字典
s = set() # 这才是定义空集合

类型转换

# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
>>> s = set([1,2,3,4])
>>> s1 = set((1,2,3,4))
>>> s2 = set({'name':'jason',}) # 遍历的是key
>>> s3 = set('egon') # 遍历的是一个个字符

集合的用法：

①关系运算

先定义两个集合friends与friends2# 1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
>>> friends1 | friends2
{'kevin', 'ricky', 'zero', 'jason', 'Jy', 'egon'}# 2.交集(&)：求两个用户的共同好友
>>> friends1 & friends2
{'jason', 'egon'}# 3.差集(-)：
>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}# 5.值是否相等(==)
>>> friends1 == friends2
False# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
# 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False# 7.子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

②去重：

集合去重复有局限性

# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序例子：
>>> l=['a','b',1,'a','a']
>>> s=set(l)
>>> s # 将列表转成了集合
{'b', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b', 'a', 1] # 去除了重复，但是打乱了顺序# 针对不可变类型，并且保证顺序则需要我们自己写代码实现（循环判断筛选）

③长度len：显示集合长度，即集合元素总个数

④in和not in：判断目标元素是否存在于集合

⑤循环：可通过for循环遍历集合中的元素

4. 可变数据类型和不可变数据类型

• 可变数据类型：变量值改变后，内存地址不变即id未变（如字典，列表，集合）
• 不可变数据类型：变量值改变后，内存地址发生改变即id也改变（如数字类型，字符串，元组）

数据类型总结：

5. 输入输出（用户交互）

用户交互就是人往计算机中input/输入数据，计算机print/输出结果，交互的本质就是输入、输出，目的是为了让计算机能够像人一样与用户沟通交流

输入input：

username=input("请输入你的账号：")

#python3中input功能用户输入的内容均存为字符串赋值给变量名，相当于python2中的raw_input 功能，而python2中的input功能则是用输入什么数据类型，就存为什么类型（python2的机制对用户不友好，需要用户了解数据类型的区别，所以python3中做了改进）

输出：即print()

print('first','second','third') # 一次性输出多个值，值用逗号隔开

重点：默认print功能有一个end参数，该参数的默认值为"n"(代表换行)，可以将end参数的值改成任意其它字符

例：print("bbbb",end='&')

格式化输出方式：

①%号

msg="my name is %s ，my age is %d" % ("lili",21)

print(msg) #这样就成为一个模板，格式化输出

• %s 通用，可接收任意类型的值，%d只能代替int整数类型 (%s、%d 叫做占位符)
• %()s 可用于字典，根据key值替换："%("key")s" % {"key":"value"}

②str.format（推荐）

• print ("my name is {}，my age is {}".format("lili",21)) #按正常顺序
• print ("my name is {1}，my age is {0}".format(21,"lili")) #使用索引
• print ("my name is {name}，my age is {age}".format(name="lili",age=21)) #使用字典
• print ("my name is {name}，my age is {age}".format(**变量名)) #使用**来解包
• print("{0:*<10}".format(变量名)) # 左对齐共10个字符，变量名内容左对齐，剩余的用*填充
• print("{0:*^10}".format(变量名)) # 居中共10个字符，变量名内容在中间，剩余的用*填充
• print("{salary:.3f}".format(salary=1232132.12351))# 精确到小数点后三位，四舍五入
• print("{0:b}".format(123))# 将变量转换成二进制（binary）
• 对象的格式化

class Person:def __init__(self):self.name = 'qqq'self.age = 19self.sex = '男'p = Person()
res = '我的名字是{0.name}，年龄是{0.age},性别是{0.sex}'.format(p)
print(res)结果：
我的名字是qqq，年龄是19,性别是男

③f-Strings（f或F） # python3.5后能用

name="lili"

age=21

print (f"my name is {name}，my age is {age}") #{}中可以是变量名，表达式等等

补充： 换行符：n 这是print默认功能的参数 print=（“abc”，end=“n”）

（一般换行需两步：先至行首，再换行 rn，python中简化了，windows未简化）

四、垃圾回收（GC）机制（回收无效变量值所占内存）

原因：在定义变量过程中解释器会申请开辟内存空间存放变量的值，而内存容量是有限的，同时有些变量值在程序运行过程中会逐渐变为无效变量即垃圾，而这些垃圾还是会占着有限的内存空间最终导致内存溢出，系统崩溃，所以我们需要一种机制管理内存来对其回收清理，释放出内存。 # Cpython自带了自动的垃圾回收机制来解决这个问题（懂得其中原理即可）

堆区和栈区

• 变量名与值的内存地址的关联关系存于栈区
• 变量值存于堆区（回收内存就是回收的堆区的内容）

直接引用和间接引用

• 直接引用指从栈区直接引到内存地址
• 间接引用指从栈区到堆区后通过进一步的引用到达最终的内存地址

垃圾回收机制大致过程：先通过“引用计数”跟踪并回收垃圾，再通过“标记-清除”解决循环引用所产生的无法回收垃圾，同时通过“分代回收”以提高垃圾回收效率

引用计数：变量值被变量名关联的次数（引用计数的增加减少都各有两种方式——直接和间接），一旦循环计数为0，那么其占用的内存就会被回收

引用计数出现的两个问题：

1.循环引用

循环引用（交叉引用）即存在相互引用，一旦两个变量都与变量值解除绑定后，变量值的引用计数不会变为0 ，其内存也就无法被回收（类似于内存泄漏）

解决方案：标记清除

当可用内存被耗尽时，就会停止程序运行，进行先标记（标记所有可以被访问到的变量值，剩余的就是无效垃圾）再清除（将没有标记的都回收）

2.效率问题

引用计数的回收机制每次都将所有对象遍历一遍会非常耗时间

解决方案：分代回收（以空间换时间）

经过多次遍历后根据变量值的存活时间将其分等级（分代），权重越高，GC扫描的频率就越低，这样每次扫描的变量的总个数就减少了，从而提高回收效率（空间换时间的原因：分代回收可能导致部分垃圾无法及时回收，但是总体会提高效率）

五、基本运算符

1.算数运算符

+、-、*、/、//（取整）、**（乘方、幂）、%（取余数，取模）

2.比较运算符（返回的是布尔值true，false）

<、>、<=、>=、==（比较对象是否相等）、!=（比较是否不相等）、<>（3.0版本已取消，比较是否不相等）

3.赋值运算（数学运算）

只要在算数运算符后面加个“=”号就是赋值运算符（“=”是最简单的赋值运算符）

c += a 等效于 c=c+a，相当于简化了代码（写代码还是要注重可读性，不能为了简化而简化）

注意：

#另外还有链式赋值x=y=z，交叉赋值m,n=n,m，解压赋值a,b,c,d=变量名（“*_”可以取首尾几个值，如：a,b,*_=nums）等，字符串、字典、元组、集合类型都支持解压赋值

4.逻辑运算（返回值为布尔值）

and、or、not（与，或，非） ，三者混合运算时有优先级（not>and>or）

• 逻辑运算时，遵循短路运算规则（运算结果一旦确定，后续运算就直接停止）
• 最好使用括号来区别优先级，先找not，再将and两边括号括起来就会变明确了

5.成员运算符（返回值为布尔值）

• in：判断一个对象是否包含于另一个对象中，字符串、列表、字典都支持运算，注意字典判断的是key，而不是冒号后面的值
• not in ：和in逻辑相反，用法相同

6.身份运算符（返回值为布尔值）

is，not is（用于计算判断id是否相同）

注意：==双等号比较的是value值

六、流程控制

流程控制具体指控制程序的执行流程，流程控制一般有三种执行流程：顺序结构（一般代码顺序）、分支结构（if判断）、循环结构（while、for循环）

1.分支结构（根据条件的不同选择执行不同分支的子代码）

使用：

if判断语句 （可以嵌套）（写完条件记得加冒号）（有单分支，双分支，多分支结构）

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

# 在if判断中，所有数据类型最后都会转化为布尔类型（真假两种情况）

注意：

• python用相同缩进(4个空格表示一个缩进)来标识一组代码块，同一组代码会自上而下依次运行
• 条件可以是任意表达式，但执行结果必须为布尔类型，None，0，空（空字符串，空列表，空字典等）三种情况下转换成的布尔值为False，其余均为True

2.循环结构（重复执行某段代码块）模仿人类重复工作的能力

使用：

2.1 while循环（条件循环）语句

while 条件：代码块
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行

# 当条件判断为true，就执行子代码块（循环体），执行完毕后再次进入循环，重新判断条件，当条件一直为true时，就相当于进入死循环，当条件变为false时，循环停止。循环语句可以简化重复代码，且及时结束循环

while+break 使用

（break用于退出本层循环，当有嵌套循环时注意break仅仅只能退一层循环）

while+continue 使用

（continue用于退出本次循环，继续进入本层的下一次循环）

while+tag 使用

（tag用于嵌套了多层while循环，想从某一层循环中直接退出所有循环，tag可以作为所有while循环的统一变量，这样一旦tag判定为false，那么就可以退出所有层的循环）

while+else 使用

（当while循环正常执行完就会继续执行else后面的代码，但如果中间有break打断，则不执行else里的代码，直接退出本层循环）

2.2 for循环语句（用于循环取值即遍历值时，比while循环使用更简洁）

for 变量名 in 可迭代对象  ： # 可迭代对象可以是字符串列表字典（key值）代码块
# 步骤1：从可迭代对象中读出第一个值赋值给变量名，然后执行循环体代码
# 步骤2：从可迭代对象中读出第二个值赋值给变量名，然后执行循环体代码
# 步骤3: 重复以上过程直到列表中的值读尽

#可迭代对象可以是字符串，列表，字典（in 是成员运算符，所以当取字典时，取的是字典中的key，而不是冒号后的值），当可迭代对象的值都取完后，循环结束，break和continue也可以用于for循环，用法和while循环相同

#range(start, stop, step)通常用于for循环中，

range(0,5,1)等同于range(0,5)表示[0,1,2,3,4],不包括5，和提取字符串方式类似(包头不包尾)

#enumerate函数 可用于 for循环 可显示列表索引号

for i in enumerate(变量名)：可同时列出具体数据和数据下标，并组成一个个元组

>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

补充：

• del 可以删除单个或多个对象
• len()：用于测量数据的长度
• range(8) 表示会逐个从0取到7， 共8个数字，可用于for循环
• 内存飙升的原因：有程序不断向内存存数据，但未及时删除无效数据，导致无效数据占据了大量内存空间
• cpu飙升的原因：CPU处于高速运算中时CPU的利用率会迅速上升，如果长期处于高处，那么可能是某个程序陷入死循环了，在不断命令CPU进行运算，要及时解决这个死循环，否则cpu可能会被烧坏