python学习精华——成长篇（二）

一、循环，判断语句，异常处理

for c in 'python':
	print(c)
#输出得到：‘p’，‘y’，‘t’，‘h’，‘o’，‘n’

不需要事先声明 c ，自动便利字符串中每一个字符。

for c in range(1,10,2):
	print(c)
#输出得到：1,3，5,7，9

range（）函数，类似切片
也可以直接遍历集合{1010，‘def’，78.9，‘78.9’}，列表[1010，‘def’，78.9，‘78.9’]，键值对{‘第一’：‘长江’，‘第二’：‘黄河’，‘第三’：‘小河’}
集合，列表，键值对，不需要range（）函数

ls = [1010，‘def’，78.9，‘78.9’，78.9]
for c in ls:
	语句块1
else:
	语句块2

for是有限循环，while是无限循环

n = 1
while n < 10:
	print(n)
	n = n+3
	if n == 4:
		break
else:
	print('正常走完')#走的过程没有遇到break，

遇到break，则会不输出‘正常走完’

while true:
	try:
		n = eval(input('输入数字'))
		break
	except:
		print('重新输入，输入数字')

常用的异常处理方法，只有真正输入数字才会返回true，才会跳出循环。

二、python中的组合（集合、列表、元组，字典）

1，集合——{…}

集合的类型是set
重点，集合输出有特点，输出顺序会变，重复的元素会消失，多个重复只保留一个，

s = {1010,‘def’,78.9,‘78.9’,78.9}
print(type(s))
#输出得到集合的类型是：set
print(s)
#{78.9,1010,‘78.9’,‘def’}

差集、交集、补集、并集
S - T : 集合S中，减去和T一样的
S & T : 输出集合S和集合T重合的
S ^ T : 输出和交集&相反的部分，即除了重合的部分
S | T :集合S和集合T合并在一起
一些方法：

s.add() #往集合s中添加元素
s.remove() #移除集合中的某个元素
s.clear()  #清空集合
a = len(s)  #获取集合存的元素个数
x in s  #判断集合x中是否含有s
x not in s  #
a = set()  #将集合组合类类型转换为集合，也可以生成空集合
a = set('知之为知之，不知为不知')  #得到集合s = {'知','之','为','不'}，也能看出来消除重复元素

2，列表——[…]

列表类型是list
重点，写入的顺序固定不变，重复的元素不会消失

ls = [1010,‘def’,78.9,‘78.9’,78.9]
print(type(ls))  #输出类型为list
print(ls) #输出为[1010,‘def’,78.9,‘78.9’,78.9]
s = list('python') #也可以用list来构建列表，或者空列表
print(ls) #输出得到['p','y','t','h','o','n']

一些方法

ls = [1010,'def',78.9,'78.9',78.9]
n = 2
print(ls * n) #将ls输出n遍
print(ls[i]) #输出ls中第i个元素
print(ls[i:j]) #输出ls中第i个到第j个元素，不包括第j个
print(ls[i:j:k]) #类似切片
print(ls.index(78.9)) #返回第一次出现78.9的下标
print(ls.count(78.9)) #返回列表中出现78.9的次数
print(ls[-2]) #下标为-2，ls中最后的78.9是-1，往前一个是-2

for i in ls
	print(i)

ls.append('red') #在ls中添加元素‘red’
ls.insert(i,'red')  #在i的位置插入元素‘red’
ls.pop(i)  #i项元素取出并删除，有返回值，返回取出来的元素
ls.remove('def') #移除ls中的‘def’元素，和pop不同，无返回值
ls.reverse() #将ls中所有元素全部翻转
lt = ls.copy() #将ls复制一份，给了lt，真正的两份，注意和lt = ls只是地址一样，实质还是同一个
del ls[1:3] #删除下标1到3的元素，同样不包括下标3
del ls[1:] #删除下标1以后的全部元素
ls[i] = 'red' #直接对ls下标为i的元素进行修改

3，元组——（…）

元组类型是：tuple
重点，元组一旦定义不可修改，所以常用来设置关键信息

tp = (1010,'def',78.9,'78.9',78.9)
print(type(tp)) #输出得到元组类型为：tuple

#因为元组一旦设置不能修改，所以只有很有限的方法可以调用
tp.count(78.9) #计算该元素在元组中的个数
tp.index('def') #计算该元素在元组中的位置

st = 'python'
print(tuple(st))
#将字符串转变为元组，输出得到（‘p’，‘y’，‘t’，‘h’，‘o’，‘n’）

4、键值对 ——{键1：值1，键2：值2，…}

键值对的类型是：dict
重点，键是唯一的不能重复，注意键值对的格式

d = {'第一':'长江','第二':'黄河','第三':'小河'}
print(type(d))
d['第三'] = '大河'
#注意，键值对无索引，只有键，即不能用0123，只能把键当做索引
print(d['第一'])

t = {} #定义一个空键值对，但是集合也是{}，且集合只能set（）定义空集合
p = dict() #也是定义一个空键值对
t['老大'] = '小王' #给空键值对直接赋值

ls1 = list(d.keys()) #返回键值对d中所有的键信息，得到一个列表
ls2 = list(d.values()) #返回键值对d中所有的值信息，得到一个列表
ls3 = list(d.items()) #返回键值对d中所有的键值对信息，得到一个嵌套列表，列表中嵌套元组（不可修改）
#ls3 = [('第一','长江'),('第二','黄河'),('第三','小河')]

a = d.get('第四','不存在') #获取对应的值，若不存在，返回‘不存在’字符串
a = d.pop('第三','不存在') #取出key‘第三’对应的值，并在原键值对中将‘第三’和对应的值删除
a = d.popitem() #随机取出一个键值对，以元组形式('第二','黄河')返回
d.clear()
del d['第二']

三、函数定义，全局变量使用，面向对象

1，有关函数定义

python中比较容易实现多个返回值

def mul (x,y = 10):#y = 10设置为默认参数，如果函数不给y赋值，则使用默认值
	return x*y,x+y
#调用
a,b = mul(99,2)#给y赋值为2，不用函数的默认值

定义函数的参数默认值必须写在所有参数的最后一个。

2，全局变量在函数内使用

全局变量就是在最外层声明的变量
但是在函数内部使用全局变量，特殊写法

n = 2
def mul():
	n = 5
	print(n)
mul()
print(n)
#输出得到5和2，意思是在函数中n改为5,只是在函数中，外面没有改

在函数中修改全局变量的值后，永久修改，加关键词global

n = 2
def mul():
	global n
	n = 5
	print(n)
mul()
print(n)
#输出得到5和5，说明在函数中的修改真正修改了全局变量

3，面向对象

类名称首字母大写，方法名小写。
编写类的说明文档，在定义类的下一行，使用三个单引号括起来。

class Car():
    ''' 汽车目前价值估计'''
    def __init__(self , make , model , year):
        self.make = make
        self.model = model
        self.year = year

类的构造函数，写完类名后，在pycharm中会自动生成，固定格式是，def init(self)：
括号中可以在self后添加构造函数参数，也可以不添加。
自己感悟，构造函数主要作用是，传递构造函数的参数，存到self中保存下来。
其次是提前声明self的属性信息。

class Car():
    ''' 汽车目前价值估计'''
    def __init__(self , make , model , year):
        self.make = make
        self.model = model
        self.year = year
my_car = Car('奥迪','A8L',2018)

继承
固定格式为，在子类名称后面的括号中，声明他的父类
在子类的构造函数中，注意参数的写法，
a,首先必须写入父类的全部参数，也可以在子类中添加新的属性，
b,其次是子类构造函数中，super().init(make,model,year)的写法，参数必须和父类一致。

class Car():
    ''' 汽车目前价值估计'''
    def __init__(self , make , model , year):
        self.make = make
        self.model = model
        self.year = year
        
class ElectricCar(Car):
    '''car 的子类，描述电动车的价值评估'''
    def __init__(self , make,model,year,elect):
        super().__init__(make,model,year)
        self.elect = elect

给类的属性设定默认值
a、在__init__中先说明self.year = 18，即说明该属性的存在。然后，可以在类外部调用时修改，比如：

my_car.year = 22

b、在类中写一个函数，专门修改参数的函数。

class Car():
    ''' 汽车目前价值估计'''
    def __init__(self , make , model , year):
        self.make = make
        self.model = model
        self.year = year
    def getyear(self,new_year):
    	self.year = new_year

导入类，导入模块
常见的关键字有“from”，“import”，可以理解为from 模块名 import 类名，并且可以从一个模块中导入多个类，比如，

from car_file import Car,ElectricCar

也可以导入整个模块，即导入模块中的所有类

import sys

四、time库、random库、turtle库

1，time库

主要功能，分析程序性能，让程序暂停。

import time
first_time = time.time()
last_time = time.time()
print(first_time)
print(last_time) #输出得到很大的浮点数，含义是秒数
print(first_time-last_time)

gmtime = time.gmtime()
print(gmtime)#返回当前时间，独特的时间结构，可以gmtime.tm_year,即点出其他信息
localtime = time.localtime()
print(localtime)#返回本地时间，独特的时间结构
ctime = time.ctime()
print(ctime)#返回字符串，正常格式的时间

t = time.localtime()
a = time.strftime('%y-%m-%d %H:%M:%S',t)
print(a)#输出特定格式的时间信息，格式可以自己编辑，比如只显示当前第几秒

暂停程序一段时间

time.sleep(2)#暂停程序两秒

2，random库

主要功能，获取随机数，广泛理解，获取随机状态（不同状态对应的数字）
还可以随机打乱一个列表，或者随机获取列表中的值
随机取得偶数或者奇数

import random
a = random.random()
print(a)

 random.seed(1)
 b = random.random()
 print(b)#种子1，固定一个随机数，一个种子，固定一个随机数

a = random.randint(1,5)
print(a)#1-5随机整数

a = random.randrange(1,10,2)
print(a)#1-10之间的，跨度为2的随机数，可以实现随机取偶数或奇数

a = random.uniform(1,5)
print(a)#1-5之间的随机小数

a = ['石头','剪刀','布']
print(random.choice(a))
random.shuffle(a)#直接把列表随机打乱，无返回值
print(a)
print(random.sample(a,2))#在列表中随机选两项，返回一个子列表

3，turtle库

turtle海龟的意思，主要用于绘制图像。
主要功能，创建窗口，画点线面，可以显示一定的动画效果。
注意，想要画画窗口一直停留，必须写，turtle.done()，否则画画窗口看不见

import turtle
turtle.setup(800,600,50,50)#设置画画的窗口大小800,600，设置画画窗口距离上下边框的距离50,50

turtle.forward(200)#画笔朝前画200
turtle.backward(400)#朝后画200

turtle.right(90)#画笔旋转顺时针旋转90°，下次旋转会记住上次旋转了多少。
turtle.forward(50)
turtle.setheading(120)#整个坐标轴旋转120°，没有记忆功能，下次旋转还会从0开始转

turtle.goto(100,100)#从当前位置画到100,100
turtle.circle(20,360)#画一个圆半径20，画满360

turtle.undo()#撤销画的上一步
turtle.speed(1)#画笔画画的速度，1到10

turtle.penup()#抬笔，也可以移动，但不会再画布上画画
turtle.forward(100)
turtle.pendown()#落笔，会在画布上画画
turtle.forward(100)

turtle.pensize(20)#画笔的粗细
turtle.color('red')#画笔颜色

turtle.begin_fill()#填充图形，begin_gill()和end_fill()必须搭配使用
turtle.color('black')
turtle.circle(100,180)#画圆，画不满也可以填充
turtle.end_fill()#搭配上面的

turtle.clear()
turtle.backward(200)#只是清空了画布的内容，画笔的位置原点都没有改变
turtle.reset()#画笔彻底复原，包括颜色大小位置
turtle.forward(200)

turtle.screensize(1000,800)#只是画布大小变了，窗口大小没有变

turtle.hideturtle()#隐藏画笔的箭头

turtle.done()