Python学习注意以下几点即可：
1. 尽量学习python3，本文以及后面的演示脚本均使用python3.6.5作为演示
2. 学习一门编程语言，最开始不要着急使用ide，比如pycharm，太智能的系统，不适合初学者
3. 在windows下学习，目前只要安装文件夹提供的两个软件即可，一个python的安装包，一个开源的开发集成环境Geany（居然有中文）
变量和简单的数据类型
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#程序员的梗
print("----------1.程序员的梗----------")
print("hello world!")
#使用变量保存字符串
print('----------2.使用变量保存字符串----------')
msg = "hello python world!"
print(msg)
#再次给变量赋值，可更新变量的值
print('----------3.再次给变量赋值，可更新变量的值----------')
msg = "hello bigdata!"
print(msg)
#变量名只能包含字母、数字和下划线，且不能以数字开头,约定变量名尽量全小写
print('----------4.变量名只能包含字母、数字和下划线，且不能以数字开头,约定变量名尽量全小写----------')
_hello_world_666 = "hello World 666"
print(_hello_world_666)
#字符串可以用""和''，为了能在字符串中使用这两种引号和'号
print('----------5.字符串可以用""和''，为了能在字符串中使用这两种引号和引号----------')
shuangyinhao = '"Hello!"'
danyinhao = "'hello!'"
piehao = "HELLO's Everyone!"
#打印以上三个字符串并使用换行符\n
print('----------6.打印以上三个字符串并使用换行符----------')
print(shuangyinhao,'\n',danyinhao,"\n",piehao)
#使用+进行字符串的拼接
print('----------7.使用+进行字符串的拼接----------')
print(" shuangyinhao:"+shuangyinhao,"\n","danyinhao:"+danyinhao,"\n","piehao:"+piehao)
#也可以在变量中进行拼接
print('----------8.也可以在变量中进行拼接----------')
pinjie_all = shuangyinhao + "---" + danyinhao + "---" + piehao
print(pinjie_all)
#使用方法:upper对字符串英文改成全大写，lower改成全小写，title改成首字母大写
print('----------9.使用方法:upper对字符串英文改成全大写，lower改成全小写，title改成首字母大写----------')
print(shuangyinhao.upper())
print(danyinhao.title())
print(piehao.lower())
#我们可以观察在print中使用以上方法，不会对变量字符串的原值有改变：
print('----------10.我们可以观察在print中使用以上方法，不会对变量字符串的原值有改变：----------')
print(shuangyinhao)
print(danyinhao)
print(piehao)
#使用lstrip删除字符串前面的空格，rstrip删除字符串后面的空格，strip删除两端的空格
print('----------11.使用lstrip删除字符串前面的空格，rstrip删除字符串后面的空格，strip删除两端的空格----------')
kong_ge = " python "
print(kong_ge+"!")
print(kong_ge.lstrip()+"!")
print(kong_ge.rstrip()+"!")
print(kong_ge.strip()+"!")
kong_ge = kong_ge.strip()
print(kong_ge)
#默认的运算是整数，支持+-*/,优先级运算符()，乘方运算符**等【注意】某些运算因为浮点精度问题，小数结果会有偏差
print('----------12.默认的运算是整数，支持+-*/,优先级运算符()，乘方运算符**等【注意】某些运算因为浮点精度问题，小数结果会有偏差----------')
print(1+1)
print(2*2)
print(5-2)
print(3/2)
print(2**10)
print((4-1)*3)
print(0.1+0.2)
#python可以先保存变量，在使用的时候再转换变量类型：
print('----------13.python可以先保存变量，在使用的时候再转换变量类型：----------')
age = 30
print("year of life is:"+str(age))
print("month of life is:"+str(age*12))
#以下print放在上面就会报错，可见变量的类型可以根据存储的内容而变化：
print('----------14.以下print放在上面就会报错，可见变量的类型可以根据存储的内容而变化：----------')
age = "30"
print("year of life is:"+age)
列表功能
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#以下是列表功能，首先创建个列表并打印出来,从这里可以看出来python对字符串的默认处理是用单引号：
print('----------1.以下是列表功能，首先创建个列表并打印出来,从这里可以看出来python对字符串的默认处理是用单引号：----------')
project = ["PM","PO","Scrum Master",123,"dev","test"]
#全列表打印出来，会包括外面的方括号
print('----------2.全列表打印出来，会包括外面的方括号----------')
print(project)
#打印列表第一个元素，使用的是下标0
print('----------3.打印列表第一个元素，使用的是下标0----------')
print(project[0])
#打印列表最后一个元素，使用的是下标-1
print('----------4.打印列表最后一个元素，使用的是下标-1----------')
print(project[-1])
#通过重新指定某个下标位置的元素修改列表元素：
print('----------5.通过重新指定某个下标位置的元素修改列表元素：----------')
project[0]="PMP"
print(project)
#在列表末尾直接增加元素：
print('----------6.在列表末尾直接增加元素----------')
project.append("check list")
print(project)
#常见的append用法为创建一个空列表，然后往里逐渐增加元素：
print('----------7.常见的append用法为创建一个空列表，然后往里逐渐增加元素：----------')
append_test = []
append_test.append("frist in")
append_test.append("second in")
append_test.append("third in")
print(append_test)
#也可以在列表任意位置插入元素，插入后插入点右边所有元素下标位置+1
print('----------8.也可以在列表任意位置插入元素，插入后插入点右边所有元素下标位置+1----------')
append_test.insert(0,"zero in")
print(append_test)
append_test.insert(2,"add")
print(append_test)
#彻底删除列表中的元素[注意]这里的del是个函数，不是方法：
print('----------9.彻底删除列表中的元素[注意]这里的del是个函数，不是方法：----------')
del append_test[2]
print(append_test)
#和上面的append有个对应的方法是pop，前者是在列表末尾增加，后者是取出并永久删除（参数为空的情况下是取列表最后一个元素）
print('----------10.和上面的append有个对应的方法是pop，前者是在列表末尾增加，后者是取出并永久删除（参数为空的情况下是取列表最后一个元素）----------')
pop_test = append_test.pop()
print(pop_test)
print(append_test)
#也可以弹出任何位置的元素，在参数中指定即可
print('----------11.也可以弹出任何位置的元素，在参数中指定即可----------')
#【注意】pop和del最大的区别是：移动和删除的区别：）
append_test.pop(0)#直接弹出，不保存值
print(append_test)
pop_test = append_test.pop(1)#弹出，保存值到变量
print(append_test)
#如果不知道要删除的元素的下标，只知道具体元素的值，可以使用remove方法进行删除
print('----------12.如果不知道要删除的元素的下标，只知道具体元素的值，可以使用remove方法进行删除----------')
remove_test = ["abc","bcd","cde","def","efg","def","def"]
print(remove_test)
remove_test.remove("def")
print(remove_test)#我们可以看到这里只删除了第一个符合的元素，如果要全部删除，需要使用循环
#列表的基本排序，使用sort对列表进行永久排序
print('----------13.列表的基本排序，使用sort对列表进行永久排序----------')
order_test_str = ['aaa','aab','abc','aba','bbb','ccc','ddd','123','234','!!!','AAA']
order_test_str.sort()#排序后顺序保存至列表
print(order_test_str)#从排序结果可以看出来，是按照ASCII码表顺序进行排序的,遇到比对等值的情况,按顺序比对下一个字符
#尝试对数字列表进行排列
print('----------14.尝试对数字列表进行排列----------')
order_test_num = [18.0,1,1.0,2,2.1,3.0,5,7.0,9,7,209,18]
order_test_num.sort()
print(order_test_num)#从结果来看,遇到等值的情况，保持原有顺序，即使一个是整数，一个是浮点数
#使用sort的参数reverse=Ture进行永久倒序排列
print('----------15.使用sort的参数reverse=Ture进行永久倒序排列----------')
print(order_test_str)
order_test_str.sort(reverse=True)#注意：T必须大写
print(order_test_str)
print(order_test_num)
order_test_num.sort(reverse=True)
print(order_test_num)#我们在这可以观察到，等值的两个数的倒序是不改变的，保持原来的顺序
#sort会改变原有的列表顺序，可以使用sorted对列表进行临时排序
print('----------16.sort会改变原有的列表顺序，可以使用sorted对列表进行临时排序----------')
sorted_test_org = [5,7,1,3,9,33,28,2,4]
sorted_test_sorted = sorted(sorted_test_org)
sorted_test_reverse = sorted(sorted_test_org,reverse=True)#这个是临时倒序排序
print(sorted_test_org)#我们可以看到原列表的顺序没有改变
print(sorted_test_sorted)
print(sorted_test_reverse)
#以上都是把无序排列成有序，如果元列表的无序本来就是有意义的，有时候需要队列表直接倒序，可以使用reverse()方法
print('----------17.以上都是把无序排列成有序，如果元列表的无序本来就是有意义的，有时候需要队列表直接倒序，可以使用reverse()方法----------')
reverse_test_org = [4,7,1,2,9,3,5,6]
print(reverse_test_org)
reverse_test_reversed = reverse_test_org.reverse()#reverse()这个方法没有返回值，所以这里没有真的赋值给变量
print(reverse_test_org)
print(reverse_test_reversed)#这里会显示none
reverse_test_org.reverse()#二次倒序=正序
print(reverse_test_org)#恢复原来的顺序
#使用len()函数可以对列表的元素数量（也就是长度）进行统计并返回
print('----------18.使用len()函数可以对列表的元素数量（也就是长度）进行统计并返回----------')
len_test = len(reverse_test_org)
print(len_test)操作列表
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#终于可以开始使用for这个循环了，在python中，for循环可以直接使用列表元素进行循环，比如以下这个
print('----------1.使用for循环拿出列表所有元素----------')
numbers = [1,3,5,7,9,2,4,6,8,10]
for number in numbers:#1.注意这里的冒号，表示下面缩进后的部分是循环执行的部分 2.注意我们并没有定义number这个变量，拿来就用了
print(number)#python有个约定，一般代表层级的缩进，默认使用tab键进行，此处一个tab键
#或者可以来个稍微看上去打印多一点的循环，从以下例子也可以看出for循环从缩进返回就结束了
print('----------2.或者可以来个稍微看上去打印多一点的循环，从以下例子也可以看出for循环从缩进返回就结束了----------')
for number in numbers:
print('I print number '+str(number))
#在python中，缩进对循环和判断的结果影响是很大的，比如上面两句如果稍微改下缩进，结果就是两个循环的嵌套了
print('----------3.在python中，缩进对循环和判断的结果影响是很大的，比如上面两句如果稍微改下缩进，结果就是两个循环的嵌套了----------')
for number in numbers:#外循环条件
print(number)#外循环执行体
for number in numbers:#内循环条件
print('I print number '+str(number))#内循环执行体
#使用range()函数生成数字
print('----------4.使用range()函数生成数字-----------')
for range_number in range(1,5):
print(range_number)#注意打印没有5，因为循环需要停止条件，5在这里是停止的条件，所以读到5就退出循环了
#使用list()把range()中的数字保存为列表
print('----------5.使用list()把range()中的数字保存为列表----------')
list_test = list(range(1,20,3))#此处range的第三个参数为步长，即每次返回是第一个数+步长*n，直到达到或者超出最后一个数退出循环
print(list_test)
#也可以使用我们之前的知识，来创造一个1-10的数的平方组成的列表
print('----------6.也可以使用我们之前的知识，来创造一个1-10的数的平方组成的列表----------')
squares = []#创建一个空的列表
for value in range(1,11):
squares.append(value**2)#把平方数填入列表
print(squares)
#还有更简单的写法--列表解析：
print('----------7.还有更简单的写法--列表解析：----------')
squares_short = [value_s**2 for value_s in range(1,11)]#注意，这里的循环没有冒号
print(squares_short)
#几个常用的对数字列表进行统计的函数：
print('----------8.几个常用的对数字列表进行统计的函数：----------')
print(min(squares))#列表最小元素
print(max(squares))#列表最大元素
print(sum(squares))#列表元素之和
#切片：对列表部分元素进行处理
print('----------9.切片：对列表部分元素进行处理----------')
cut = [0,1,2,3,4,5,6,7,8,9,10,11]
print(cut[0:5])#指定打印范围为下标0到4（5为结束）的列表元素
print(cut[5:])#指定打印范围为下标5到列表结束的列表元素
print(cut[-4:])#指定打印倒数4个列表元素
print(cut[2:-5])#指定打印下标2到倒数下标5之间的列表元素
#我们当然也可以在循环中使用切片
print('----------10.我们当然也可以在循环中使用切片----------')
for cut_loop in cut[2:-5]:
print(cut_loop)
#复制切片（或者整个列表）
print('----------11.复制切片（或者整个列表）----------')
cut_bak_all = cut[:]#不指定切片的起始和结束，即为整个列表
cut_bak_connect = cut#这个是个错误演示，不能直接把列表赋值给变量，变量会成为这个列表的“快捷方式”，或者叫别名，请观察以下代码结果
print(cut)
print(cut_bak_all)
print(cut_bak_connect)
cut.append(100)
cut_bak_all.append(200)
cut_bak_connect.append(300)
print(cut)
print(cut_bak_all)
print(cut_bak_connect)
#元组--不可单独更改元素的列表（暂时这么理解）
print('----------12.组--不可单独更改元素的列表（暂时这么理解）----------')
cant_change = (0,1,2,3)#注意，这里是圆括号，用方括号是列表，用圆括号是元组
print(cant_change)
#尝试更改元组里的元素---元组的元素不可单独更改
#去掉注释查看下面的报错，还有个注意点是元组虽然使用圆括号创建，但是下标还是使用方括号
#cant_change[0] = 9
#整体赋值（或者叫更改）元组是可行的
print('----------14.整体赋值（或者叫更改）元组是可行的----------')
print(cant_change)
cant_change = (4,5,6)
print(cant_change)
#到这里也算是python入门了,需要讲下python约定的基本代码格式：1.缩进使用制表符或者4个空格，或者其倍数 2.python代码每行长度不要超过80个字符,主要是方便程序员查看代码（不会产生拖动）
#3.空行不会影响代码执行,但是可以增强或者减弱代码的可读性,需要谨慎使用if语句
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#在学if语句前一定要先知道，if语句一定有个表达式的结果是布尔值（True或者False）
#先看下常见的布尔值表达式【注意】在比较运算符前后增加空格，是为了方便查看，也是大部分程序员遵守的约定
#在python中，大小写的比对结果是不等的：
print('----------1.在python中，大小写的比对结果是不等的：----------')
qq = 'qq'
QQ = 'QQ'
print(qq == QQ)
#有一种办法，能无视用户输入的大小写：
print('----------2.有一种办法，能无视用户输入的大小写：----------')
print(qq == QQ.lower())
#以上都是相等的判断为True,还有一种比较运算符是!= 即是不等为true
print('----------3.以上都是相等的判断为True,还有一种比较运算符是!= 即是不等为true----------')
print(qq != QQ)
#对数字的比较除了以上两种，还有>,<,>=,<=这4个比较运算符
print('----------4.对数字的比较除了以上两种，还有>,<,>=,<=这4个比较运算符----------')
print(1 > 2)
print(1 < 2)
print(1 >= 1)
print(1 <= 2)
#有多个布尔值需要判断的时候，请使用and和or来进行多判断条件的建立
print('----------5.有多个布尔值需要判断的时候，请使用and和or来进行多判断条件的建立----------')
print((1 == 1)and(1 > 2))#结果为False，因为and中有一个为False就是False，所以有多个and连接条件时，有一个是False就直接返回值了，后面的表达式就不执行了
print((1 == 1)or(1 > 2))#结果为True，因为or中有一个为True就是True，所以有多个or连接条件时，有一个True就直接返回值了，后面的表达式就不执行了
#关键字in可以用来判断值是否存在于列表中
print('----------6.关键字in可以用来判断值是否存在于列表中----------')
in_test = [1,2,3,4,5]
print(1 in in_test)
print(6 in in_test)
#关键字not in可以用来判断值是否不存在于列表中
print('----------7.键字not in可以用来判断值是否不存在于列表中----------')
in_test = [1,2,3,4,5]
print(1 not in in_test)
print(6 not in in_test)
#if是“根据条件判断进行选择”的基础语句，最基本的用法如下：表达式结果是True就执行if后的语句，表达式结果是False就执行else后的语句
print('----------8.if基本用法----------')
numbers = [1,2,3,4,5,6]
for number in numbers:
if number == 6:
print(number,number,number)#只有符合条件的输出了3次
else:#这句和以下这句不是必须的，可以注释掉试试~~
print(number)
#if-elif(多个elif)-else语句是用来分类执行的，类似于"我今天想喝可乐，去超市买，每个if(elif)都是一种饮料，我依次掠过果汁，苏打水，牛奶，拿到满足需求的可乐"，然后下一个循环是想喝苏打水的:)
#以下循环循环了3次，每次找到合适的”出口“，就打印相应的变量，跳过后面的判断，用新值重新对号入座
print('----------9.elif基本用法----------')
elif_test = ['book','computer','TV','music']
for thing in elif_test:
if thing == "TV":
print('I have '+thing)
elif thing == "computer":
print('I play '+thing)
elif thing == "music":
print('I like listening to '+thing)
else:
print('I read '+thing)
#一个简单的判断方法，就是一个if使用中最多只有一个输出，无论后面有多少个elif字典
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#python的字典可以保存数据之间的对应关系，比我们之前学的列表功能强大一些，列表用[]，元组用()，字典只能用{}了(这格式，确定不是json么)
print('----------1.字典基本构成----------')
test = {'PM':'Project Manager',"age":32}#标准格式,test叫字典名，'PM'叫键，'Project Manager'是'PM'这个键对应的键值,键和值合起来叫“键-值对”
print(test['PM'])#注意，我们看到列表，元组，字典访问某个元素都是用的[]
print(test["age"])#我们看到单双引号对结果没有影响
print(test)#这样会打印全部字典内容
#给字典增加新的元素
print('----------2.给字典增加新的元素-----------')
test_add = {'a':1,'b':2,'c':3}
print(test_add)
test_add['d'] = 4
print(test_add)
#一般字典在程序中的用法是先建立空的字典，然后使用上述语句逐渐增加键-值
print('----------3.一般字典在程序中的用法是先建立空的字典，然后使用上述语句逐渐增加键-值----------')
add_test = {}
add_test['one'] = 1
add_test['two'] = 2
add_test['three'] = 3
print(add_test)
#字典键值的更改也很简单，直接给对应的键赋新键值即可
print('----------4.字典键值的更改也很简单，直接给对应的键赋新键值即可----------')
change_test = {'color':'red'}
change_test['color'] = 'green'
print(change_test)
#删除的时候，要指定字典名和对应的键
print('----------5.删除的时候，要指定字典名和对应的键----------')
del_test = {'a':1,'b':2,'c':3}
print(del_test)
del del_test['b']
print(del_test)
#遍历整个字典，可以使用for循环进行遍历(以下字典写法方便查看键值对的信息)
print('----------6.遍历整个字典，可以使用for循环进行遍历----------')
test = {
'A':'Aino',
'b':'Bob',
'c':'Chary'
}
for key,value in test.items():
print("\nkey: " + key)
print("value: " + value)
#也可以用keys()方法来拿字典中所有的键信息
print('----------7.也可以用keys()方法来拿字典中所有的键信息----------')
keys_test = {
'fast':5,
'middle':3,
'slow':1
}
for speed in keys_test.keys():
print(speed)
#用values()方法来拿字典中所有的键值信息
print('----------8.用values()方法来拿字典中所有的键值信息----------')
values_test = {
'a':100,
'b':200,
'c':200
}
for number in values_test.values():
print(number)#我们在这里可以观察到，取出得值是不会去重的，有两个200的值
#如果想拿到去重的键值的，和已使用集合函数set()
print('----------9.如果想拿到去重的键值的，和已使用集合函数set()----------')
for number in set(values_test.values()):
print(number)
#到这里我们已经掌握了三种python数据结构：列表，元组，字典，这三种数据结构是可以互相嵌套的，我们可以看下常见的嵌套
#列表嵌套其它数据结构为元素：
print('----------10.列表嵌套其它数据结构为元素----------')
list_list = [1,2,3]
list_dict = {'d':4,'e':5,'f':6}
list_tuple = (520,666)
list_all_in = [list_list,list_dict,list_tuple]#分别嵌套了列表，字典和元组
print(list_all_in)
#字典嵌套其它数据结构为键值：
print('----------11.字典嵌套其它数据结构为键值----------')
dict_list = [1,2,3,4,5]
dict_dict = {'a':'a','b':'b','c':'c'}
dict_tuple = ('read','only')
dict_all_in = {'number':dict_list,'letter':dict_dict,'tuple':dict_tuple}
print(dict_all_in)
#元组嵌套其它数据结构为元素：
print('----------12.元组嵌套其它数据结构为元素----------')
tuple_list = [1,2,3,4,5]
tuple_dict = {'a':'a','b':'b','c':'c'}
tuple_tuple = ('read','only')
tuple_all_in = (tuple_list,tuple_dict,tuple_tuple)
print(tuple_all_in)
#以上是python常用的数据结构，请多看几遍，并尝试更改嵌套结构里的元素或值，真正理解了后再往后看。用户输入和while循环
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#input()函数能很方便的让用户输入信息
print('----------1.input()函数能很方便的让用户输入信息----------')
message = input('输入任何你想说的话：')
print('你说的话是：'+message)
#input()函数收集的信息，都会保存为字符串(str)类型，所以如果把用户返回保存为其它类型，需要强制转换
print('----------2.使用int()函数强制转换用户输入的字符串为整数----------')
notes = '请输入你的年龄'#使用下面这种方式写字符串是为了方便查看，否则都在一行
notes += '\n限定输入类型为数字'#使用运算符+=可以附加字符串内容，执行完本行后notes的值为'请输入你的年龄\n限定输入类型为数字'
age = input(notes)
age = int(age)#强制转换为整数
print('你的年龄为'+str(age)+'\n已成年'+str(age-18)+'年')
#求模运算符是求除数后的余数的，比如3/2的余数是1，比如20/3的余数是2
print('----------3.求模运算符的使用----------')
number = input("输入一个整数，我会告诉你这个是奇数还是偶数: ")
number = int(number)
if number % 2 == 0:
print("\n这个数字 " + str(number) + " 是偶数")
else:
print("\n这个数字 " + str(number) + " 是奇数")
#while循环和for循环的差别是：while的循环退出条件是自己写的，for的循环退出条件是遍历全部列表（元组，字典）或者指定的切片
print('----------4.while的基本用法----------')
while_number = 1
while while_number <= 5:
print(while_number)
while_number += 1#等价于while_number = while_number + 1
#可以结合input和while来做个小程序
print('----------5.可以结合input和while来做个小程序----------')
message = ''
while message != 'quit':
print('输入任何你想说的话：')
message = input(message)
print('你想说的话是：'+message+'\n退出请输入quit')
#布尔值变量作为while的条件时，只要值是True就一直循环，直到布尔值为false时退出循环
print('----------6.布尔值变量作为while的循环条件----------')
active = True
message = ''
while active:
print('输入任何你想说的话：')
message = input(message)
if message == 'quit':
active = False
else:
print('你想说的话是：'+message+'\n退出请输入quit')
#使用break立刻退出循环，不需要满足while（或者for）循环退出的条件
print('----------7.使用break立刻退出循环，不需要满足while（或者for）循环退出的条件----------')
message = ''
while True:#这里写死，判断一直会执行
print('输入任何你想说的话：')
message = input(message)
if message == 'quit':
break
else:
print('你想说的话是：'+message+'\n退出请输入quit')
#使用continue可以忽略循环体下面的代码，开始新一轮循环
print('----------8.使用continue可以忽略循环体下面的代码，开始新一轮循环----------')
number = 0
while number <= 10:
number += 1
if number % 3 != 0:
continue
print(number)#注意这个print的位置
#注意使用while的时候要小心设置退出条件，否则会造成无限循环的情况，比如上面注释掉number += 1
#####使用while处理列表和字典#####
#在列表之间移动元素
print('----------9.在列表之间移动元素----------')
numbers_list = [1,3,11,5,28,2,6]
empty_list = []
print('numbers_list列表内容为：'+str(numbers_list))
print('empty_list列表内容为：'+str(empty_list))
while numbers_list:#这里如果是个列表，会判断列表是否为空，为空会退出循环
number_temp = numbers_list.pop(0)#这里不加下标会导致列表翻转
empty_list.append(number_temp)
print('numbers_list列表处理后内容为：'+str(numbers_list))
print('empty_list列表处理后内容为：'+str(empty_list))
#记得我们之前说过，remove()能查找列表元素并删除，但是只能删除找到的第一个，现在可以用while删除所有符合条件的元素了
print('----------10.用while删除列表中某个值的元素----------')
letters = ['a','b','a','b','b','a','a','b','b','b','a','a','b','a','b','a','b','b']
print('列表内容为：'+str(letters))
while 'b' in letters:#循环条件是列表中的'b'没有了退出循环
letters.remove('b')
print('列表处理后内容为：'+str(letters))
#使用用户输入来填充字典
print('----------11.使用用户输入来填充字典----------')
name_age = {}
active = True
while active:
name = input('请输入姓名：')
age = input('请输入年龄：')
name_age[name] = age
continue_temp = input('还需要继续录入么?(y/n)')
if continue_temp.lower() == 'n':
active = False
print('你的录入结果为：')
print(name_age)函数
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#定义一个函数
print('----------1.定义一个函数----------')
def hello():#定义了一个函数名字叫hello()
print('hello python world')#函数体，就是具体函数要完成的逻辑
print('我的第一个函数：')
hello()
#给函数添加一个参数
print('----------2.给函数添加一个参数----------')
def hello_my_friend(name):#我们把这个函数中的变量name叫形参
print('hello,'+name.title()+'!')
hello_my_friend('aino')#我们把使用这个函数的时候，传入的参数'aino'叫实参,这个实参传给了函数hello_my_friend,存储在形参name中
#位置实参
print('----------3.位置实参----------')
def im(im_type,im_number):#定义了两个形参，而且形参是有序的
print('IM的类型是：' + im_type)
print('IM的号码是：' + im_number)
im('QQ','30278257')#调用函数传实参的时候，顺序很重要，所以叫“位置实参”
im('微信','Aino531')
#关键字实参
print('----------4.关键字实参----------')
#关键字实参的就是实参传参的时候带上形参：
im(im_type='QQ',im_number='30278257')#可以这么理解，在传实参的时候就指定了保存实参的形参，而不是用实参的位置来确定形参
im(im_number='Aino531',im_type='微信')#注意这里专门调换了实参的顺序，但是结果不会影响
#形参默认值
print('----------5.形参默认值----------')
def contact(phone_number,phone_type = 'cellphone'):#这里给形参phone_type默认值为'cellphone'，如果没有给这个形参传实参，则直接使用默认值[注意]我们把有默认值的参数放后面，方便只传没有默认值的情况
print('电话类型：' + phone_type)
print('电话号码：' + phone_number)
contact('18192087986')#只传第一个实参，第二形参用默认值
contact('82796852','telephone')#位置实参的方式传实参
contact(phone_type='Iphone',phone_number='15991278957')#也不影响关键字实参的传递
#contact()#试试在函数调用的时候不传参，看看会报什么错
#形参默认值的扩展---让形参成为可选
print('----------6.形参默认值的扩展---让形参成为可选----------')
def abc(a,b,c=''):#这里提供的形参c给了默认值''空字符串，意思是如果没有传参就不使用
print(a)
print(b)
print(c)
abc('test','dev')#我们看到这里没有传实参c，但是不影响函数的结果
abc('first','second','end')#传了第实参c，也能正常运行
#函数的返回值
print('----------7.函数的返回值----------')
def square(number,exponent):
result = number**exponent
return result#把result的值返回给整个函数
print(square(2,10))#直接从函数层面拿到数据
#返回一个字典
print('----------8.返回一个字典----------')
def contact_dict(name,phone):
dict_temp = {'姓名':name,'电话号码':phone}
return dict_temp
print(contact_dict('Aino','18192085297'))
#使用while循环的函数
print('----------9.使用while循环的函数----------')
def while_loop(round_number,start_number = 1):#定义了一个循环次数和循环起始数的函数
max_number = round_number + start_number
while start_number < max_number:
print(str(start_number))
start_number += 1
while_loop(5)
while_loop(4,100)
#传递列表
print('----------10.传递列表----------')
def list_use(nums):
for num in nums:#函数内定义了形参类型为列表
print(num**2)
nums = [1,2,3,4,5]
#nums = 1#可以尝试注释掉上一句，把这句的注释去掉，看看报错
list_use(nums)
#在函数中修改列表
print('----------11.在函数中修改列表----------')
def list_move(full_list,empty_list):#修改后的列表是实实在在被修改了，不仅仅是在函数内
while full_list:
temp = full_list.pop(0)
print('列表数据移动:'+str(temp))
empty_list.append(temp)
print('源列表: '+str(full_list))
print('目标列表: '+str(empty_list))
start = [1,3,6,9,7,11,666]
end = []
list_move(start,end)
print('最终两个列表内容为：')
print(start)
print(end)
#禁止函数修改列表
print('----------12.禁止函数修改列表----------')
letter_start = ['a','b','c','d','e','f']
letter_end = []
list_move(letter_start[:],letter_end)#在使用实参的时候给列表后面加上[:]，即为创建源列表的副本并在本函数中使用，在函数中的所有对副本列表的操作不影响源列表
print('最终两个列表内容为：')
print(letter_start)#我们可以看到源列表并没有被清空
print(letter_end)
#使用任意数量的位置实参
print('----------13.使用任意数量的位置实参----------')
def add_more(one,*everything):#在形参前加*号，意味着本形参可以接收多个实参并保存在元组，[注意]我们把可多次传参的参数放后面，方便使用
print(everything)#形参接收的复数实参被存储在以形参命名的元组中
add_more(1,'test')#观察这里的数据格式，是用()，即为元组
add_more(2,'dev','PM',22)#3个也可以处理
#使用任意数量的关键字实参
print('----------14.使用任意数量的关键字实参----------')
def more_add(first,last,**info):#在形参前加**号，意味着本形参可以接收多个键值对并保存在字典，[注意]我们把可多次传参的参数放后面，方便使用
profile = {}#建立一个空的字典
profile['first_name'] = first
profile['last_name'] = last
for key,value in info.items():#注意这里的写法
profile[key] = value
return profile
result = more_add('Aino','low',fev='game',food='rice',luck_number=9)
print(result)
################################################以下部分是关于函数模块引用的###################################################################
#将函数存储在模块中---以下代码需要依赖invike.py，请把invoke.py和本文件放在一个目录下
print('----------15.将函数存储在模块中----------')
#函数是可以放在模块中的，模块就是某个.py的文件，比如我们现在的这个py就可以被调用，为了方便，我在外面写了个invoke.py的模块，里面有两个函数invoke_loop()和invoke_sum()
import invoke#这样就可以引用所有包含在invoke.py这个模块中的所有函数
print('-----引用模块-----')
invoke.invoke_sum(10,100)#引用方法是：模块名.函数名
import invoke as i#引用模块中的所有函数并给模块起个别名i，调用的时候用别名调用
print('-----引用模块并起别名-----')
i.invoke_sum(2,8)#引用方法是：模块别名.函数名
from invoke import invoke_sum#这样就只引用invoke模块中的invoke_sum这个函数
print('-----引用一个函数-----')
invoke_sum(1,10)#引用方法是：函数名，这种引用方法就不用写模块名
from invoke import invoke_loop,invoke_sum#使用逗号可以一次引用一个模块中多个函数
print('-----引用多个函数-----')
invoke_loop(3,4)
from invoke import invoke_sum as sa#引用这个函数并给它起个别名sa，调用的时候用别名调用
print('-----引用函数并起别名-----')
sa(4,8)#能最简调用函数的办法，可以直接调用且函数名字自定义
from invoke import *#模块的函数全部引用，且调用不用输入模块名，方便但是一般不这么用，因为函数名称可能冲突，有问题也不好找函数来源
print('-----引用模块下的所有函数-----')
invoke_loop(5,100)
invoke_sum(666,888)
#函数编写的约定：1.函数名称要意义明确，方便使用者看到函数名就知道用途
#2.函数在最前面应该有描述性的注释，内容包括且不限于：函数的用处，需要的形参，返回值的格式等等
#3.调用函数的时候，关键字实参的'='两端不要加空格
#4.形参过多导致一行代码过长（超过78个字符），请使用以下格式
def parameters(
aaa,bbb,ccc,ddd,eee,#这里使用两个'tab'或者8个空格
fff,ggg,hhh,iii,jjj):
print('hello every parameter!')invoke
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
def invoke_loop(round_number,start_number = 1):#定义了一个循环次数和循环起始数的函数
max_number = round_number + start_number
while start_number < max_number:
print(str(start_number))
start_number += 1
def invoke_sum(*number):#一个可以计算复数位置实参平方和的函数
square_list = []
for value in number:
square = value**2
square_list.append(square)
sum_all = sum(square_list)
print('计算的结果为： '+str(sum_all))
return sum_all类
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#类是面向对象编程很重要的概念，不过第一次接触，会觉得很抽象，我们来创建个类来讲解吧：
print('----------1.第一个python类----------')
class Human(): #class + 类名 +() 建立个类就这么简单，要注意的是在python中，所有类要首字母大写
#关于类的理解：
#1.我们平常说的“人类”就是一个类，类是从某种类型的事物中抽象出来的概念，包含这类事物共同的特性，比如“我要消灭人类！”，指的是所有人，而不是某个个体。
#2.“对象”就是类中具体的事物，对应到现实中，”人类“的某个对象就是具体的某个人，所以”我要消灭 山豆根 = Human('Aino','man',38)“，其实是要消灭由Human()这个类实例化的山豆根
"""这里的信息叫文档字符串，用来做类的说明"""
def __init__(self,name,sex,age): #类中的函数，我们叫方法，其操作和普通的函数一样
self.name = name #'__init__是一个特殊的方法，每次根据类创建新实例时，都会自动运行，所以这里的形参如果没有默认值就必传
self.sex = sex #self是一个指向实例本身的引用，让实例可以访问类中的方法和属性，在这里，我们把"self.sex"这个变量叫做属性，是对实例“性别”的描述
self.age = age #self不用传实参，在下面的调用中可以看到
def run(self): #这个方法不用传参，并且是某个类“肯定有”的抽象描述，所以使用"self"让所有的实例都能调用这个方法
print(self.name.title() + '正在跑')
def jump(self):
print(self.name.title() + '正在跳')
def stage(self):
if self.age < 35:
print('我是年轻人！')
else:
print('我已经找不到工作了！')
#调用我们创建的类
print('----------2.调用我们创建的类----------')
aino = Human('aino','man',38) #根据Human()类创建实例aino，并传递三个属性
print('我的名字叫'+aino.name.title()) #属性可以直接通过这种方式调用
print('我今年'+str(aino.age)+'岁了')
aino.stage() #方法可以这样调用，和函数一样，调用必须传参，哪怕是空
#当然我们能使用类实例化多个对象
print('----------3.当然我们能使用类实例化多个对象----------')
linda = Human('linda','woman',33)
print('我的名字叫'+linda.name.title())
print('我今年'+str(linda.age)+'岁了')
linda.run()
#继承一个类
print('----------4.继承一个类----------')
#在python中，继承一个类可以获得一个类所有的属性和方法，所以原来的类叫父类，继承父类的类叫子类，子类除了继承父类所有的能力外，还能定义自己独有的属性和方法
class GodHuman(Human):
"""神人类会比他的父类人类多出方法和属性，青出于蓝而胜于蓝"""
def __init__(self,name,sex,age):#此处是初始化父类的属性
super().__init__(name,sex,age)#super是指从父类继承__init__()这个方法，由于父类也叫superclass，所以这里的函数就叫super()
self.god_ability = '瞬间移动'#在这里增加新的属性
def run(self): #如果方法和父类的方法名一样，会覆盖父类的方法，我们把这个操作叫重写
print(self.name.title() + '已经快飞起来了')
tom = GodHuman('tom','man',28)
print('我的名字叫'+tom.name.title())
print('我今年'+str(tom.age)+'岁了')
print('我们神人拥有'+tom.god_ability+'的能力')
tom.stage()
tom.run() #我们可以看到重写的方法生效了
#将实例用作属性(类的拆分)
print('----------5.将实例用作属性(类的拆分)----------')
#在某些情况下，类中的属性和方法会越来越多，我们可以把功能有共同点的属性或方法单独放在小类中，最后会形成类似树状结构
class GodHumanAbility(): #创建一个类用来专门保存能力这个属性
"""把神人的能力单独拿出来做一个类"""
def __init__(self,ability1='时间静止',ability2='时间倒流'):
self.ability1 = ability1
self.ability2 = ability2
def describe_ability(self): #创建一个打印能力的方法
print('神人的能力增加了'+self.ability1+'和'+self.ability2)
class GHuman(Human): #继承human类
"""继承Human父类并使用GodHumanAbility类"""
def __init__(self,name,sex,age):
super().__init__(name,sex,age)
self.ability = GodHumanAbility() #给这个属性赋予GodHumanAbility类的能力
jerry = GHuman('jerry','man',25)
print('我的名字叫'+jerry.name.title())
print('我今年'+str(jerry.age)+'岁了')
jerry.ability.describe_ability() #一层一层调用下来就能用了:)
jerry.stage()
#导入类
print('----------6.导入类----------')
#导入类就不演示了，和上一章的在模块中调用函数一样，把一个或者多个类放到一个文件中，用import或者from xxx import xxx来导入即可
#类名应采用 驼峰命名法 ，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线
#两个方法之间一个空行，两个类之间两个空行文件和异常
#coding=utf-8
#不加上面的就不能使用中文(取决于你保存文本的编码方式)
#本演示程序使用python版本为3.6.5
#powerd by 山豆根行者 QQ:30278257 QQ群：345648345
#数据需要保存，我们先用简单的数据保存，把数据直接放在txt中进行读取和保存
#示范用的txt文件需要保存为ANSI格式，否则会有各种报错
print('----------1.文件的读取----------')
#我们把test.txt文件和本程序放在同一个目录：
with open('test.txt') as file_object: #对文件操作前要先打开(open)，在使用完成后需要关闭(close)，但是使用'with'关键字，只要打开使用文件即可，python会在合适的时候关闭文件
test = file_object.read() #读取上面保存在对象中的数据
print(test)
#当然，我们也可以放在别的目录下(windows下的示范)
print('----------2.把文件放在任意地方读取----------')
file_path = 'd:/test.txt'
with open(file_path) as test_object:
test1 = test_object.read()
print(test1)
#linux系统的文件路径请自行百度，可以相对路径也可以绝对路径
#可以按行读取文件内容
print('----------3.按行读取文件内容----------')
with open('test.txt') as file_object:
test = file_object.readline() #只读取了第1行
print(test)
for line in file_object:
print(line) #会继续读取剩下的2行，可见在一次open内，不会读取相同的内容
for line in file_object:
print(line) #通过这行验证上面的结论
#按行读取有个问题，就是会读取换行符，可以使用rstrip()来消除
print('----------4.消除读取单行或者逐行读取中间的空行----------')
with open('test.txt') as test_obj:
for lines in test_obj:
print(lines.rstrip()) #使用rstrip()方法就可以删除换行符
#把读取的文件内容按行保存为列表，供以后在程序中使用
print('----------5.把读取的文件内容按行保存为列表，供以后在程序中使用----------')
with open('test.txt') as t_obj:
text_list = t_obj.readlines()
print(text_list) #我们可以看到列表里的元素有/n，在使用列表的时候可以用rstrip()方法删除
#把保存的列表输出成一行
one_line = ''
for line in text_list:
one_line += line.rstrip() #循环保存去除/n的每行到one_line
print(one_line)
print('文件包含的文字数为：'+str(len(one_line))) #统计文本文字数
#一个重要的方法：保存文件内容为列表后，通过读取切片获取部分数据---不用读取全部文件
print('----------6.存文件内容为列表后，通过读取切片获取部分数据----------')
piece_line = ''
for line in text_list[1:3]: #切片只读取list的第2个第3个元素
piece_line += line.rstrip()
print('使用切片只读取部分内容：' + piece_line)
#对文件进行写操作
print('----------7.对文件进行写操作----------')
with open('writetest.txt','w') as write_object: #如果文件不存在，就会直接创建。'w'是对文件操作的权限，分为'w'写 'r'只读 'a'附加 和 'r+'读写,如果不传这个参数，默认是'r'只读【注意】'w'会在打开文件同时清空文件内容
write_object.write('这是我第一次写文件') #用write方法直接对文件写入，可以出去验证下是否写入，这里就不在程序里读了
write_object.write('试试继续往里面写')
write_object.write('尝试写入后换个行\n')
write_object.write('验证下换行成功了没\n')
#对文件进行附加操作
print('----------8.对文件进行附加操作----------')
#由于open()文件时'w'参数会清空文件内容，所以要在现有文件上增加内容，需要在打开的时候使用'a'参数，意思为从文件末尾增加
with open('writetest.txt','a') as add_obj:
add_obj.write('试试add内容到之前的文件中\n')
add_obj.write('再添加一行试试')
#异常的处理-使用try-except
print('----------8.异常的处理-使用try-except----------')
try: #try代码块开始，代码块的内容是有可能报错的代码
print(3/0) #这样写肯定会报错，但是报错不会以traceback的方式报出，而是去执行和try对应的except代码块
except ZeroDivisionError: #抛出了ZeroDivisionError这个异常，并执行异常后面的代码块
print('你不能除以零！') #打出你已经定义好的信息
#在程序中使用try-except-else
print('----------9.在程序中使用try-except-else----------')
#异常的处理有两个好处：1.可以显示自定义的报错 2.可以不让程序因为异常而崩溃
print('一个简单的除法计算器')
print('输入q可以退出计算器')
while True:
dividend = input('请输入被除数')
if dividend == 'q':
break
divisor = input('请输入除数')
if divisor == 'q':
break
try:
answer = int(dividend)/int(divisor)
except ZeroDivisionError:
print('你不能除以零！')
else: #用这种方式可以让代码继续往下跑
print(str(dividend)+'除以'+str(divisor)+'的结果是：'+str(answer))
#结合学过的知识，创建一个可以计算英文文档有多少单词的函数
print('----------9.结合学过的知识，创建一个可以计算英文文档有多少单词的函数----------')
def wordcount():
"""计算一个英文文档能有多少个单词"""
filename = input('本程序能计算英文文档包含的英文单词数量，请输入要统计的英文文档名称，包含后缀')
try:
with open(filename) as f_obj:
text = f_obj.read()
except FileNotFoundError:
#pass#可以是用关键字pass在这里不做任何处理，如果有这关键字，会忽略本代码块中所有的代码,去掉本行起始的#查看效果
print('在本程序目录下没有找到'+str(filename)+'这个文件，请核对后再试！')
else:
text_l = text.split()
counts = len(text_l)
print('这个英文文档大概有'+str(counts)+'个英文单词')
#调用一下这个试试
wordcount()
#终于到了我们用的最多的功能：json的处理
print('----------10.终于到了我们用的最多的功能：json的处理----------')
import json
json_dict = {'name':'aino','sex':'man','age':38}
with open('test.json','w') as jsonw_obj:
json.dump(json_dict,jsonw_obj,sort_keys=True, indent=4, separators=(',', ': ')) #我们可以在这出去看看字典是否保存到文件中
with open('test.json','r') as jsonr_obj:
t_dict = json.load(jsonr_obj)
print('读取的json内容为'+str(t_dict))
if json_dict == t_dict:
print('两个字典的内容是一样的')
else:
print('两个字典的内容不一致')
#在这里提一下，json.dumps可以把字典转换成str，json.loads是把str转换成字典，但是并不是对文件的操作。
#这里提一下什么是重构，重构就是你写的代码很多逻辑没有封装成函数，为了使代码逻辑更加清晰，把已有的逻辑重新划分成函数和模块的方式，叫重构
更多推荐
Python从0基础学习
发布评论