Python学习（01-09day）

包括了各种基础知识、基本函数、结构以及练习题与实例题的运行代码、结果截图、出现的错误，供日后回顾。

从docx上粘贴而来（图片转存失败）

DAY1（7.11）（阶段性目标，学习github上1-9天的内容）

1.在vsc上安装好了Python,运行了hello world;

运行了import this,看Python之禅.

hello, world!

The Zen of Python, by Tim Peters

Beautiful is better than ugly.

Explicit is better than implicit.

Simple is better than complex.

Complex is better than complicated.

Flat is better than nested.

Sparse is better than dense.

Readability counts.

Special cases aren't special enough to break the rules.

Although practicality beats purity.

Errors should never pass silently.

Unless explicitly silenced.

In the face of ambiguity, refuse the temptation to guess.

There should be one-- and preferably only one --obvious way to do it.

Although that way may not be obvious at first unless you're Dutch.

Now is better than never.

Although never is often better than *right* now.

If the implementation is hard to explain, it's a bad idea.

If the implementation is easy to explain, it may be a good idea.

Namespaces are one honking great idea -- let's do more of those!

你好，世界！

《Python之禅》，作者：蒂姆·彼得斯

美丽胜于丑陋。

显性比隐性好。

简单胜于复杂。

复杂总比复杂好。

平的比嵌套的好。

疏胜于密。

可读性很重要。

特殊情况不足以打破规则。

尽管实用胜过纯洁。

错误不应该悄悄地过去。

除非明确沉默。

面对模棱两可，拒绝猜测的诱惑。

应该有一个——最好只有一个——显而易见的方法。

尽管这种方式一开始可能并不明显，除非你是荷兰人。

现在总比没有好。

虽然从来没有比现在更好。

如果实现很难解释，那就不是个好主意。

如果实现很容易解释，那么这可能是一个好主意。

名称空间是一个非常好的主意——让我们做更多的工作吧！

学习使用turtle在屏幕上绘制图形。

说明：turtle是Python内置的一个非常有趣的模块，特别适合对计算机程序设计进行初体验的小伙伴，它最早是Logo语言的一部分，Logo语言是Wally Feurzig和Seymour Papert在1966发明的编程语言。

import turtle

turtle.pensize(4)

turtle.pencolor('red')//定义画笔颜色为红色

turtle.forward(100)

turtle.right(90)

turtle.forward(100)

turtle.right(90)

turtle.forward(100)

turtle.right(90)

turtle.forward(100)

turtle.mainloop()

实现了从左上顶点，到右上，到右下，最后回到左上的一个路径

还有一个画小猪佩奇的代码，感觉挺有意思，但是看不懂

继续学习02语言元素

①type函数可以对变量的类型进行检查

例如：a = 100

b = 12.345

c = 1 + 5j

d = 'hello, world'

e = True

print(type(a)) # <class 'int'>

print(type(b)) # <class 'float'>

print(type(c)) # <class 'complex'>

print(type(d)) # <class 'str'>

print(type(e)) # <class 'bool'>

②可以使用Python中内置的函数对变量类型进行转换。

int()：将一个数值或字符串转换成整数，可以指定进制。
float()：将一个字符串转换成浮点数。
str()：将指定的对象转换成字符串形式，可以指定编码。
chr()：将整数转换成该编码对应的字符串（一个字符）。
ord()：将字符串（一个字符）转换成对应的编码（整数）

使用input()函数获取键盘输入(字符串)

使用int()函数将输入的字符串转换成整数

使用print()函数输出带占位符的字符串

a = int(input('a = '))

b = int(input('b = '))

print('%d + %d = %d' % (a, b, a + b))

结果截图：

%称作占位符

上面的print函数中输出的字符串使用了占位符语法，其中%d是整数的占位符，%f是小数的占位符，%%表示百分号（因为百分号代表了占位符，所以带占位符的字符串中要表示百分号必须写成%%），字符串之后的%后面跟的变量值会替换掉占位符然后输出到终端中，运行上面的程序，看看程序执行结果就明白啦。

③运算符

Python支持多种运算符，下表大致按照优先级从高到低的顺序列出了所有的运算符，运算符的优先级指的是多个运算符同时出现时，先做什么运算然后再做什么运算。除了我们之前已经用过的赋值运算符和算术运算符，我们稍后会陆续讲到其他运算符的使用。（如果不清楚运算符的优先级，可以使用括号）

④逻辑运算符

逻辑运算符有三个，分别是and、or和not。and字面意思是“而且”，所以and运算符会连接两个布尔值，如果两个布尔值都是True，那么运算的结果就是True；左右两边的布尔值有一个是False，最终的运算结果就是False。相信大家已经想到了，如果and左边的布尔值是False，不管右边的布尔值是什么，最终的结果都是False，所以在做运算的时候右边的值会被跳过（短路处理），这也就意味着在and运算符左边为False的情况下，右边的表达式根本不会执行。or字面意思是“或者”，所以or运算符也会连接两个布尔值，如果两个布尔值有任意一个是True，那么最终的结果就是True。当然，or运算符也是有短路功能的，在它左边的布尔值为True的情况下，右边的表达式根本不会执行。not运算符的后面会跟上一个布尔值，它的作用是得到与该布尔值相反的值，也就是说，后面的布尔值如果是True运算结果就是False，而后面的布尔值如果是False则运算结果就是True。

flag0=1==1 #flag0=True

flag1=3>2 #flag1=True

flag2=2<1 #flag2=False

flag3=flag1 and flag2

print('flag0=',flag0)

print('flag3=',flag3)

比较运算符的优先级高于赋值运算符，所以flag0 = 1 == 1先做1 == 1产生布尔值True，再将这个值赋值给变量flag0。print函数可以输出多个值，多个值之间可以用,进行分隔，输出的内容之间默认以空格分开。

练习1：华氏温度转换为摄氏温度

华氏温度到摄氏温度的转换公式为：$C=(F - 32) / 1.8$

F=float(input('f='))

C=(F - 32) / 1.8

print('%.1f华氏度=%.1f摄氏度'%(F,C))

结果截图：

print中，利用%.1f占用一个浮点数的位置，代表保留一位有效数字，也可以使用

print(F'{F:.1f}华氏度 = {C:.1f}摄氏度')

其中{f:.1f}和{c:.1f}可以先看成是{f}和{c}，表示输出时会用变量f和变量c的值替换掉这两个占位符，后面的:.1f表示这是一个浮点数，小数点后保留1位有效数字。

练习2：输入圆的半径输出周长和面积

R=float(input('R=')) #半径可以是小数

S=3.14*R*R #面积，π选用3.14

L=2*3.14*R #周长

print('面积=%.2f'%S)

print('周长=%.2f'%L)

（注意：print中的S前的%千万别忘，忘记后会提示如下错误）

练习3：输入年份是不是闰年

（# 如果代码太长写成一行不便于阅读可以使用\对代码进行折行）

①、普通年能被4整除且不能被100整除的为闰年。（如2004年就是闰年，1900年不是闰年）

②、世纪年能被400整除的是闰年。（如2000年是闰年，1900年不是闰年）

year = int(input('请输入年份: '))

# 如果代码太长写成一行不便于阅读可以使用\对代码进行折行

is_leap = year % 4 == 0 and year % 100 != 0 or \

year % 400 == 0

print(is_leap)

结果截图：

03.分支结构

迄今为止，我们写的Python代码都是一条一条语句顺序执行，这种代码结构通常称之为顺序结构。

也就是说，有的问题有多个可能性，单纯使用顺序结构难以解决.

If-else语句。需要注意的是，if,else后面都需要:,而且if与else需要上下对齐。

例如：

一个系统只当用户名和指令都正确才能进入。

username=input('请输入用户名:')

password=input('请输入密码')

if username=='wangguan' and password =='123456':

print('身份验证成功!')

else:

print('身份验证失败!')

需要说明的是和C/C++、Java等语言不同，Python中没有用花括号来构造代码块而是使用了缩进的方式来表示代码的层次结构，如果if条件成立的情况下需要执行多条语句，只要保持多条语句具有相同的缩进就可以了。换句话说连续的代码如果又保持了相同的缩进那么它们属于同一个代码块，相当于是一个执行的整体。缩进可以使用任意数量的空格，但通常使用4个空格，建议大家不要使用制表键或者设置你的代码编辑工具自动将制表键变成4个空格。

当然如果要构造出更多的分支，可以使用if...elif...else...结构或者嵌套的if...else...结构，下面的代码演示了如何利用多分支结构实现分段函数求值。

if x > 1:

y = 3 * x - 5

elif x >= -1:

y = x + 2

else:

y = 5 * x + 3

（注意elif,类似于else if）

(或者可以再else之后进行缩进，代表嵌套结构，其中有下一个else-if结构)

if x > 1:

y = 3 * x - 5

else:

if x >= -1:

y = x + 2

else:

y = 5 * x + 3

之前我们提到的Python之禅中有这么一句话“Flat is better than nested.”，之所以提倡代码“扁平化”是因为嵌套结构的嵌套层次多了之后会严重的影响代码的可读性，所以能使用扁平化的结构时就不要使用嵌套。（能不嵌套尽量不用）

练习1.英制单位英寸与公制单位厘米互换

（需要判断单位是英寸还是厘米，再换成另外的，如果单位不对，还要重新输入）

value=float(input('请输入长度：'))

unit=input('请输入单位：')

if unit=='in'or unit=='英寸':

print('%f英寸=%f厘米'%(value,value*2.54))

elif unit=='cm'or unit=='厘米':

print('%f厘米=%f英寸'%(value,value/2.54))

else:

print('请输入有效单位')

练习2.百分制成绩转换成等级制成绩

要求：如果输入的成绩在90分以上（含90分）输出A；80分-90分（不含90分）输出B；70分-80分（不含80分）输出C；60分-70分（不含70分）输出D；60分以下输出E。

value=int(input('请输入成绩'))

if value>=90:

grade='A'

elif value>=80:

grade='B'

elif value>=70:

grade='C'

elif value>=60:

grade='D'

else:

grade='E'

print('对应的等级是:',grade)

（可以看到，例如value在80到90之间时，不许设置条件<=90）

练习3：输入三条边长，如果能构成三角形就计算周长和面积

(能构成三角形的条件是，任意两边之和大于第三边)

A=int(input('请输入第一条边长'))

B=int(input('请输入第二条边长'))

C=int(input('请输入第三条边长'))

if A+B>C and B+C>A and A+C>B: #满足两边之和大于第三边，则计算面积

print('三角形周长为:',A+B+C)

p= (A +B + C) / 2

area = (p * (p - A) * (p - B) * (p - C)) ** 0.5

print('三角形面积为:', area)

else:

print('不能构成三角形!')

04循环结构

①for-in循环

如果明确的知道循环执行的次数或者要对一个容器进行迭代（后面会讲到），那么我们推荐使用for-in循环，例如下面代码中计算1~100求和的结果（$\displaystyle \sum \limits_{n=1}^{100}n$）。

sum = 0

for x in range(101):

sum += x

print(sum)

上面代码中的range(1, 101)可以用来构造一个从1到100的范围，当我们把这样一个范围放到for-in循环中，就可以通过前面的循环变量x依次取出从1到100的整数。当然，range的用法非常灵活，下面给出了一个例子：

range(101)：可以用来产生0到100范围的整数，需要注意的是取不到101。
range(1, 101)：可以用来产生1到100范围的整数，相当于前面是闭区间后面是开区间。
range(1, 101, 2)：可以用来产生1到100的奇数，其中2是步长，即每次数值递增的值。
range(100, 0, -2)：可以用来产生100到1的偶数，其中-2是步长，即每次数字递减的值

实现1-100之间的偶数求和

num=0

for x in range(2,101,2):

num+=x

print(num)

（特别要注意range的用法,并且边界是取不到的）

②while循环(不知道具体的循环次数)

DAY2(7.12)

练习1：输入一个正整数判断是不是素数（从2判断到根号n即可,开方运算，使用sqrt）

from math import sqrt

num=int(input('输入想要判断的数字:'))

end=int(sqrt(num) ) #这里需要注意将开方设置为int型

is_prime=True

for x in range(2,end+1):

if num%x==0:

is_prime=False

break

if is_prime and num!=1:

print('%d是素数'%num)

else:

print('%d不是素数'%num)

练习2：输入两个正整数，计算它们的最大公约数和最小公倍数。

（//代表相除并且向下取整）

（x,y=y,x代表交换x,y的值）

num1=int(input('输入数字1:'))

num2=int(input('输入数字2:'))

if num1>num2:

num1,num2=num2,num1

for x in range(num1,0,-1):

if num1%x==0 and num2%x==0:

print('%d和%d的最大公约数是%d' % (num1, num2, x))

print('%d和%d的最小公倍数是%d' % (num1, num2, num1 * num2 // x))

break

练习3：打印如下所示的三角形图案。

（输出结束，需要在后面加一个end=’’）例如： print('*', end='')

***

****

*****

***

****

*****

***

*****

*******

*********

row=int(input('请输入行数:'))

for x in range(row):

for _ in range(x+1):

print('*',end='')

print()

for i in range(row):

for j in range(row):

if j < row - i - 1:

print(' ', end='')

else:

print('*', end='')

print()

for i in range(row):

for _ in range(row - i - 1):

print(' ', end='')

for _ in range(2 * i + 1):

print('*', end='')

print()

05.构造程序逻辑（练习）

（建立程序中的逻辑以及如何运用一些简单的算法解决现实中的问题）

寻找水仙花数

说明：水仙花数也被称为超完全数字不变数、自恋数、自幂数、阿姆斯特朗数，它是一个3位数，该数字每个位上数字的立方之和正好等于它本身，例如：$1^3 + 5^3+ 3^3=153$。

（幂运算用**表示，三次方即是**3）

(出现问题：，意味着是缩进出了问题，检查第一行是否顶格写)

for x in range(100,1000,1): #要求是三位数，100到999

num1=x//100 #num1代表百位数

num2=(x-100*num1)//10 #num2代表十位数字

num3=(x-100*num1-10*num2) #num3为个位数字

if num1**3+num2**3+num3**3==x:

print(x)

水仙花数一共有四个。

将一个整数反转

num=int(input('请输入需反转的数:'))

res =int(0) #用来记录结果

while(num !=0):

res=res*10+num%10

num=num//10

print(res)

百钱百鸡问题

说明：百钱百鸡是我国古代数学家张丘建在《算经》一书中提出的数学问题：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？翻译成现代文是：公鸡5元一只，母鸡3元一只，小鸡1元三只，用100块钱买一百只鸡，问公鸡、母鸡、小鸡各有多少只？

CRAPS赌博问题

说明：CRAPS又称花旗骰，是美国拉斯维加斯非常受欢迎的一种的桌上赌博游戏。该游戏使用两粒骰子，玩家通过摇两粒骰子获得点数进行游戏。简单的规则是：玩家第一次摇骰子如果摇出了7点或11点，玩家胜；玩家第一次如果摇出2点、3点或12点，庄家胜；其他点数玩家继续摇骰子，如果玩家摇出了7点，庄家胜；如果玩家摇出了第一次摇的点数，玩家胜；其他点数，玩家继续要骰子，直到分出胜负。

（需要使用随机数，且区间为位于2到12）语句：from random import randint

first = randint(1, 6) + randint(1, 6)

from random import randint

money = 1000

while money > 0:

print('你的总资产为:', money)

needs_go_on = False

while True:

debt = int(input('请下注: '))

if 0 < debt <= money:

break

first = randint(1, 6) + randint(1, 6)

print('玩家摇出了%d点' % first)

if first == 7 or first == 11:

print('玩家胜!')

money += debt

elif first == 2 or first == 3 or first == 12:

print('庄家胜!')

money -= debt

else:

needs_go_on = True

while needs_go_on:

needs_go_on = False

current = randint(1, 6) + randint(1, 6)

print('玩家摇出了%d点' % current)

if current == 7:

print('庄家胜')

money -= debt

elif current == first:

print('玩家胜')

money += debt

else:

needs_go_on = True

print('你破产了, 游戏结束!')

（赌博害人..不输光不走）

练习1.生成斐波那契数列的前20个数

斐波那契数列的特点是数列的前两个数都是1，从第三个数开始，每个数都是它前面两个数的和，形如：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...。

num1=1

num2=1

print(1)

for x in range(1,19):

num3=num1+num2

print(num3)

num1=num2

num2=num3

参考答案的简洁代码：

range(20)代表就是从0到19，注意简化range（5）等价于range（0， 5）

练习2.找出10000以内的完美数

说明：完美数又称为完全数或完备数，它的所有的真因子（即除了自身以外的因子）的和（即因子函数）恰好等于它本身。例如：6（$6=1+2+3$）和28（$28=1+2+4+7+14$）就是完美数。完美数有很多神奇的特性，有兴趣的可以自行了解。

（1肯定包括在内，寻找区间在1到根号x，防止因数出现两遍）

import math

for num in range(2, 10000):

result = 0

for factor in range(1, int(math.sqrt(num)) + 1):

if num % factor == 0:

result += factor

if factor > 1 and num // factor != factor:

result += num // factor

if result == num:

print(num)

四个完美数

练习3.输出100以内所有素数

import math

for num in range(2, 100):

is_prime = True

for factor in range(2, int(math.sqrt(num)) + 1):

if num % factor == 0:

is_prime = False

break

if is_prime:

print(num, end=' ')

（注意is_prime的使用）

06.函数和模块的使用

定义函数

在Python中可以使用def关键字来定义函数，和变量一样每个函数也有一个响亮的名字，而且命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，这一点和数学上的函数非常相似，程序中函数的参数就相当于是数学上说的函数的自变量，而函数执行完成后我们可以通过return关键字来返回一个值，这相当于数学上说的函数的因变量。

函数的参数

函数是绝大多数编程语言中都支持的一个代码的"构建块"，但是Python中的函数与其他语言中的函数还是有很多不太相同的地方，其中一个显著的区别就是Python对函数参数的处理。在Python中，函数的参数可以有默认值，也支持使用可变参数，所以Python并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式，

（不确定参数个数的时候可以使用可变参数）

因为我们可能会对0个或多个参数进行加法运算，而具体有多少个参数是由调用者来决定，我们作为函数的设计者对这一点是一无所知的，因此在不确定参数个数的时候，我们可以使用可变参数，代码如下所示。

# 在参数名前面的*表示args是一个可变参数

def add(*args):

total = 0

for val in args:

total += val

return total

# 在调用add函数时可以传入0个或多个参数

print(add())

print(add(1))

print(add(1, 2))

print(add(1, 2, 3))

print(add(1, 3, 5, 7, 9))

用模块管理函数

对于任何一种编程语言来说，给变量、函数这样的标识符起名字都是一个让人头疼的问题，因为我们会遇到命名冲突这种尴尬的情况。最简单的场景就是在同一个.py文件中定义了两个同名函数，由于Python没有函数重载的概念，那么后面的定义会覆盖之前的定义，也就意味着两个函数同名函数实际上只有一个是存在的。

Python中每个文件就代表了一个模块（module），我们在不同的模块中可以有同名的函数，在使用函数的时候我们通过import关键字导入指定的模块就可以区分到底要使用的是哪个模块中的foo函数，代码如下所示。

把下面这块搞懂

DAY3(7.13)

练习一.实现求最大公约数和最小公倍数的函数

（注意1.函数参数的输入2.每个函数都要有return3.函数声明之后要有:）

def MaxYueShu(x,y): #求最大公因数

if x>y :

x,y=y,x

for a in range(x,0,-1): #既然是最大公约数，从后往前寻找

if x%a==0 and y%a==0:

return a

(求最小公倍数，用两数相乘在除以最大公约数)

运行时出现问题如下：

解决方法：注意缩进问题并解决之，成功运行

def MinBeiShu(x,y):

"""求最小公倍数"""

return x*y// MaxYueShu(x,y)

结果截图

print(MinBeiShu(2,3))

练习二.实现判断一个数是不是回文数的函数

（是判断数字）

（需要注意的点：因为每次循环，x变为x//10,所以提前需要令temp=x来存值）

#判断回文数

def HuiWen(x):

res=0

temp=x

while(x!=0):

res=res*10+x%10

x=x//10

return res==temp

print(HuiWen(12121))

结果截图：

练习三：判断素数

#判断一个数是不是素数

def is_prime(num):

for factor in range(2, int(num ** 0.5) + 1):

if num % factor == 0:

return False

return True if num != 1 else False

练习四：判断是否是回文素数（将上两个函数结合）

if __name__ == '__main__':（只有直接执行的模块的名字才是"__main__"）

num = int(input('请输入正整数: '))

if is_palindrome(num) and is_prime(num):

print('%d是回文素数' % num)

当我们将代码中重复出现的和相对独立的功能抽取成函数后，我们可以组合使用这些函数来解决更为复杂的问题，这也是我们为什么要定义和使用函数的一个非常重要的原因。

变量的作用域（全局变量与局部变量）

如果希望在局部修改全局变量，可以使用global关键字来指示函数中的变量a来自于全局作用域，

如foo()函数中。如果全局作用域中没有a，那么下面一行的代码就会定义变量a并将其置于全局作用域。

函数中嵌套函数，内嵌函数可以使用外部函数中定义的变量
函数中定义的变量在函数外无法访问

应该尽量减少对全局变量的使用，因为全局变量的作用域和影响过于广泛，可能会发生意料之外的修改和使用，除此之外全局变量比局部变量拥有更长的生命周期，可能导致对象占用的内存长时间无法被垃圾回收。

如果我们希望将一个局部变量的生命周期延长，使其在定义它的函数调用结束后依然可以使用它的值，这时候就需要使用闭包，这个我们在后续的内容中进行讲解。

从现在开始我们可以将Python代码按照下面的格式进行书写，这一点点的改进其实就是在我们理解了函数和作用域的基础上跨出的巨大的一步。

07字符串和常用数据结构

在字符串中使用\（反斜杠）来表示转义，也就是说\后面的字符不再是它原来的意义，例如：\n不是代表反斜杠和字符n，而是表示换行；而\t也不是代表反斜杠和字符t，而是表示制表符。所以如果想在字符串中表示'要写成\'，同理想表示\要写成\\。

在\后面还可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。也可以在\后面跟Unicode字符编码来表示字符，例如\u9a86\u660a代表的是中文“骆昊”。

如果不希望字符串中的\表示转义，我们可以通过在字符串的最前面加上字母r来加以说明

可以使用+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符（切片运算），

切片运算：从哪一个下标到另外一个下标

[2::2]代表从下标2开始，每隔2个取一个

[::2]从头开始，每隔两个取一个

[::-1]从尾部开始，从后往前依次输出

[-3::-1]尾部是-1,往前递减

字符串处理方法

len() :输出长度

capitalize() :将字符串首字母大写

title() :每个单词首字母大写

upper() :字符串全部大写

find(‘’) :查找子串所在位置

startswith() :判断是否以某字符串开头

endswith() :是否以某字符串结尾

center（50，‘*’）:以指定的宽度居中并在两侧填充指定字符

rjust(50,‘’):以指定的宽度靠右放置左侧填充指定的字符

isdigit() :是否由数字构成

isalpha():是否以字母构成

isalnum():是否以数字和字母构成

strip():修建左右两侧空格之后的拷贝

注意最后一种表达方式

列表（list），也是一种结构化的、非标量类型，它是值的有序序列，每个值都可以通过索引进行标识，定义列表可以将列表的元素放在[]中，多个元素用,进行分隔，可以使用for循环对列表元素进行遍历，也可以使用[]或[:]运算符取出列表中的一个或多个元素。

定义、遍历以及列表的下标运算

通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值

for index, elem in enumerate(list1):

print(index, elem)

添加元素、移除元素

append():在最后添加元素

insert(i,x):在i的位置上插入x

合并两个列表:list1+=list2

remove(x):删除元素x

pop(i):删除i处的元素

clear():清空列表

字符串的切片操作

需要注意的是：

[i:j]，i是取的，j不取，即左闭右开
对于-的使用，最后一位是-1，往前依次递减
反向切片：(倒转列表)

[::-1]

排序操作

sorted函数返回列表排序后的拷贝不会修改传入的列表

sorted是对列表中字符串的首字母进行排序

list3 = sorted(list1, reverse=True)这是对排序后进行反转

list4 = sorted(list1, key=len)是利用字符串长度由短到长进行排序

.sort可以对原列表进行排序，sorted需要对新列表进行赋值

生成式和生成器

f = [x for x in range(1, 10)]

print(f)

f = [x + y for x in 'ABCDE' for y in '1234567']

print(f)

注意第二种表达方式：x+y代表将x与y中的元素依次相加

# 请注意下面的代码创建的不是一个列表而是一个生成器对象

# 通过生成器可以获取到数据但它不占用额外的空间存储数据

# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)

f = (x ** 2 for x in range(1, 1000))

print(sys.getsizeof(f))

# 相比生成式生成器不占用存储数据的空间

print(f)

for val in f:

print(val)

注：使用函数sys.getsizeof之前要先import sys

Python中还有另外一种定义生成器的方式，就是通过yield关键字将一个普通函数改造成生成器函数。下面的代码演示了如何实现一个生成斐波拉切数列的生成器。所谓斐波拉切数列可以通过下面递归的方法来进行定义：

使用元祖

元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。

定义元祖

获取元组中的元素

遍历元组中的值

由于元祖的元素不能修改，可以先转换成列表，再修改元素

已经有了列表这种数据结构，为什么还需要元组这样的类型呢？

元祖中的数据不能修改，在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。
元组在创建时间和占用的空间上面都优于列表。

元祖和列表定义的区别：

元祖是使用()小括号进行赋值，列表是使用[]中括号进行赋值

见下方，集合是使用{}大括号进行赋值

使用集合

不允许有重复元素，而且可以进行交集、并集、差集等运算

构造器语法见面向对象详解，推导式语法是由条件建立的

add():在集合最后加入元素

update也是在最后加入，但是是列表形式

diacard(x)删除集合中的x元素

remove也是删除某一元素

集合的成员、交集、并集、差集等运算。

交集：&

并集：|

差集：-

对称差：^(对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。)

判断子集和超集：

使用字典

字典是另一种可变容器模型，Python中的字典跟我们生活中使用的字典是一样一样的，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。下面的代码演示了如何定义和使用字典。

创建字典：用{}大括号

zip函数可以将两个序列压成字典，挨个成为键值对

通过键可以获得对应的值

遍历：使用f’{key}:’

更新元素

# get方法也是通过键获取对应的值但是可以设置默认值

删除元素

清空字典：clear

练习1：在屏幕上显示跑马灯文字

（跑马灯文字就是一直在移动，前进后出）

Import os:在python下写程序，需要对文件以及文件夹或者其他的进行一系列的操作(在python环境下对文件，文件夹执行操作的一个模块)

例如：
os.name返回当前系统
os.getcwd()返回当前的路径
os.remove(路径）删除路径下的文件

Import time:时间模块

Time.sleep(x)代表休眠x秒

cls是清屏函数

Content[1:]+content[0]代表将字符串的第一位元素移到最后，很好理解

import os

import time

def main():

content = '北京欢迎你为你开天辟地…………'

while True:

# 清理屏幕上的输出

os.system('cls') # os.system('clear')

print(content)

# 休眠200毫秒

time.sleep(0.2)

content = content[1:] + content[0]

if __name__ == '__main__':

main()

练习2：设计一个函数产生指定长度的验证码，验证码由大小写字母和数字构成。

import random

def generate_code(code_len=4):

all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

last_pos = len(all_chars) - 1

code = ''

for _ in range(code_len):

index = random.randint(0, last_pos)

code += all_chars[index]

return code

默认四位

随机产生数，用random模块

将所有大小字母与数字放入字符串，随机产生0到len-1的数字作为选取下标，将四位构成验证码

练习3：设计一个函数返回给定文件名的后缀名（后缀名就是文件名中.后面的）

def get_suffix(filename, has_dot=False):

"""

获取文件名的后缀名

:param filename: 文件名

:param has_dot: 返回的后缀名是否需要带点

:return: 文件的后缀名

"""

pos = filename.rfind('.') #先找到文件名中的.因为前面是名，后面是后缀

if 0 < pos < len(filename) - 1: #如果.的下标在0到len-1，之间

index = pos if has_dot else pos + 1 #如果需要包括点，即has_dot为true，则索引是.的下标，否则是.的下标+1

return filename[index:] #[index:]是返回从index到末尾的子串

else:

return ''

filename.rfind(‘.’)：查找filenama字符串中.的位置

Index=pos if has_dot else pos+1(这种写法一定要注意)

练习4：设计一个函数返回传入的列表中最大和第二大的元素的值。

#求列表前两个最大的数字

def max2(x):

m1,m2=(x[0],x[1]) if x[0]>x[1] else (x[1],x[0])

for index in range(2,len(x)):

if x[index] > m1:

m2 = m1

m1 = x[index]

elif x[index] > m2:

m2 = x[index]

return m1, m2

练习5：计算指定的年月日是这一年的第几天（需要先判断是闰年还是非闰年）

（将每个月的天数作为列表，按照月份数字，依次相加）

DAY4.(7.14)

练习6：打印杨辉三角

def main():

num = int(input('Number of rows: ')) #

yh = [[]] * num #先创建num个空列表

for row in range(len(yh)):

yh[row] = [None] * (row + 1)

for col in range(len(yh[row])):

if col == 0 or col == row:

yh[row][col] = 1 #先将收尾赋值为1

else:

yh[row][col] = yh[row - 1][col] + yh[row - 1][col - 1]

print(yh[row][col], end='\t')

print()

if __name__ == '__main__':

main()

注意：1.先创建num行空的列表

2.将收尾赋值1

注意这一句：yh[row] = [None] * (row + 1)

第row行有row+1个元算，先对每行初始化

print(yh[row][col], end='\t')

是换行输出

07day的最后三个案例有些难度

综合案例一：双色球选号

关于random模块：用来生成随机数

具体方法:

1.random.random():用于生成一个0到1的随机浮点数：0<=n<1.0

2.random.uniform(a,b):用于生成某一范围内的浮点数

3.random.randint(a,b)：用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n：a<=n<=b

4.random.randrange([start],[stop], [step])：从指定范围内，按指定基数递增的集合中获取一个随机数。如：random.randrange(10,100,2)，结果相当于从[10,12,14,16,…,96,98]序列中获取一个随机数。random.randrange(10,100,2)在结果上与random.choice(range(10,100,2))等效。

5.random.choice(sequence)：参数sequence表示一个有序类型。sequence在python不是一种特定的类型，而是泛指一系列的类型。list，tuple，字符串都属于sequence。

random.shuffle(x)：用于将一个列表中的元素打乱。

import random

p=['pyhton','is','powerful','simple','and so on…']

random.shuffle(p)

print(p)

random.sample(sequence,k)：从指定序列中随机获取指定长度的片段，sample函数不会修改原有序列。

import random
list=[1,2,3,4,5,6,7,8,9,10]
a=random.sample(list,5) #从list中随机获取5个元素，作为一个片段返回
print a
[1, 6, 10, 8, 3]

from random import randrange, randint, sample

def display(balls):

"""

输出列表中的双色球号码

"""

for index, ball in enumerate(balls):

if index == len(balls) - 1:

print('|', end=' ')

print('%02d' % ball, end=' ')

print()

def random_select():

"""

随机选择一组号码

"""

red_balls = [x for x in range(1, 34)]

selected_balls = []

selected_balls = sample(red_balls, 6)

selected_balls.sort()

selected_balls.append(randint(1, 16))

return selected_balls

def main():

n = int(input('机选几注: '))

for _ in range(n):

display(random_select())

if __name__ == '__main__':

main()

综合案例2：约瑟夫环问题。

这个错误，是由于制表符与空格不同引起的，混用了TAB键和空格

def main():

persons = [True] * 30

counter, index, number = 0, 0, 0

while counter < 15:

if persons[index]:

number += 1

if number == 9:

persons[index] = False

counter += 1

number = 0

index += 1

index %= 30

for person in persons:

print('基' if person else '非', end='')

if __name__ == '__main__':

main()

08面向对象基础

类和对象

简单的说，类是对象的蓝图和模板，而对象是类的实例。这个解释虽然有点像用概念在解释概念，但是从这句话我们至少可以看出，类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。

定义类

在Python中可以使用class关键字定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来，代码如下所示。

# __init__是一个特殊方法用于在创建对象时进行初始化操作

# 通过这个方法我们可以为学生对象绑定name和age两个属性

写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息

创建和使用对象

注意细节：

在类中定义函数def(self,...)第一个参数self代表自身
在主函数中创建对象，stud1=Student(i,j)

其中Student是类的名，其中的参数是除了self之外的参数

修改对象中的函数，stud.study()
调用函数，stud.watch_mavie

访问可见性问题

在Python中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头

可以看到，foo和bar前面都有__,(这是两个下划线，连在一起了)

__bar和__foo,都将其设置为了私有

Python并没有从语法上严格保证私有属性或方法的私密性，它只是给私有的属性和方法换了一个名字来妨碍对它们的访问，事实上如果你知道更换名字的规则仍然可以访问到它们，下面的代码就可以验证这一点。之所以这样设定，可以用这样一句名言加以解释，就是"We are all consenting adults here"。因为绝大多数程序员都认为开放比封闭要好，而且程序员要自己为自己的行为负责。

像这样就可以访问私有函数

并不建议将属性设置为私有的，因为这会导致子类无法访问（后面会讲到）。所以大多数Python程序员会遵循一种命名惯例就是让属性名以单下划线开头来表示属性是受保护的，本类之外的代码在访问这样的属性时应该要保持慎重。这种做法并不是语法上的规则，单下划线开头的属性和方法外界仍然是可以访问的，所以更多的时候它是一种暗示或隐喻

面向对象的支柱

面向对象有三大支柱：封装、继承和多态

对封装的理解是"隐藏一切可以隐藏的实现细节，只向外界暴露（提供）简单的编程接口"。我们在类中定义的方法其实就是把数据和对数据的操作封装起来了，在我们创建了对象之后，只需要给对象发送一个消息（调用方法）就可以执行方法中的代码，也就是说我们只需要知道方法的名字和传入的参数（方法的外部视图），而不需要知道方法内部的实现细节（方法的内部视图）。

练习：

练习1：定义一个类描述数字时钟

（main 函数应该和class对齐）

from time import sleep

class Clock(object):

def __init__(self,hour=0,minute=0,second=0):

self._hour = hour

self._minute = minute

self._second = second

def run(self):

self._second+=1

if self._second==60:

self._second = 0

self._minute += 1

if self._minute==60:

self._minute = 0

self._hour+=1

if self._hour == 24:

self._hour = 0

def show(self):

"""显示时间"""

return '%02d:%02d:%02d' % \

(self._hour, self._minute, self._second)

def main():

clock = Clock(23, 59, 58)

while True:

print(clock.show())

sleep(1)

clock.run()

if __name__ == '__main__':

main()

练习2：定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法。

from math import sqrt

class point(object):

def __init__(self,x=0,y=0):

self.x=x

self.y=y

def move_to(self, x, y):

"""移动到指定位置

:param x: 新的横坐标

"param y: 新的纵坐标

"""

self.x = x

self.y = y

def move_by(self,dx,dy):

self.x+=dx

self.y+=dy

def distance(self,other):

dx = self.x - other.x

dy = self.y - other.y

return sqrt(dx ** 2 + dy ** 2)

def __str__(self):

return '(%s, %s)' % (str(self.x), str(self.y))

def main():

p1 = point(3, 5)

p2 = point()

print(p1)

print(p2)

p2.move_by(-1, 2)

print(p2)

print(p1.distance(p2))

if __name__ == '__main__':

main()

09day 面型对象进阶

@property装饰器

之前的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。

可以看到，声明@property后，可以访问，可以修改

slots魔法

Python是一门动态语言。通常，动态语言允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效，对子类并不起任何作用。

静态方法(staticmethod)和类方法

之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。实际上，我们写在类中的方法并不需要都是对象方法，例如我们定义一个“三角形”类，通过传入三条边长来构造三角形，并提供计算周长和面积的方法，但是传入的三条边长未必能构造出三角形对象，因此我们可以先写一个方法来验证三条边长是否可以构成三角形，这个方法很显然就不是对象方法，因为在调用这个方法时三角形对象尚未创建出来（因为都不知道三条边能不能构成三角形），所以这个方法是属于三角形类而并不属于三角形对象的。我们可以使用静态方法来解决这类问题，代码如下所示。

（意思就是，静态方法在对象出现之前就有，类中可以进行调用）

还可以在类中定义类方法(classmethod)，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象，代码如下所示。

类之间的关系

简单的说，类和类之间的关系有三种：is-a、has-a和use-a关系。

is-a关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系。
has-a关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。
use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。

利用类之间的这些关系，我们可以在已有类的基础上来完成某些操作，也可以在已有类的基础上创建新的类，这些都是实现代码复用的重要手段。复用现有的代码不仅可以减少开发的工作量，也有利于代码的管理和维护，这是我们在日常工作中都会使用到的技术手段。

继承和多态

刚才我们提到了，可以在已有类的基础上创建新类，这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来，从而减少重复代码的编写。提供继承信息的我们称之为父类，也叫超类或基类；得到继承信息的我们称之为子类，也叫派生类或衍生类。子类除了继承父类提供的属性和方法，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力，在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为，对应的原则称之为里氏替换原则。下面我们先看一个继承的例子。

（继承的概念很好理解，主要看继承的具体代码以及使用到的一些函数）

（继承，是一个小类继承一个大类，小类包含大类的所有特点，同时自己也具有新的特点，例如人是大类，学生、老师是一个小类，可以继承类人）

class Person(object):

"""人"""

def __init__(self, name, age):

self._name = name

self._age = age

@property

def name(self):

return self._name

@property

def age(self):

return self._age

@age.setter

def age(self, age):

self._age = age

def play(self):

print('%s正在愉快的玩耍.' % self._name)

def watch_av(self):

if self._age >= 18:

print('%s正在观看爱情动作片.' % self._name)

else:

print('%s只能观看《熊出没》.' % self._name)

class Student(Person):

"""学生"""

def __init__(self, name, age, grade):

super().__init__(name, age)

self._grade = grade

@property

def grade(self):

return self._grade

@grade.setter

def grade(self, grade):

self._grade = grade

def study(self, course):

print('%s的%s正在学习%s.' % (self._grade, self._name, course))

class Teacher(Person):

"""老师"""

def __init__(self, name, age, title):

super().__init__(name, age)

self._title = title

@property

def title(self):

return self._title

@title.setter

def title(self, title):

self._title = title

def teach(self, course):

print('%s%s正在讲%s.' % (self._name, self._title, course))

def main():

stu = Student('王大锤', 15, '初三')

stu.study('数学')

stu.watch_av()

t = Teacher('骆昊', 38, '砖家')

t.teach('Python程序设计')

t.watch_av()

if __name__ == '__main__':

main()

继承类的声明:如student类继承person类，这样声明

class Student(Person):

由于person类中已经包括了name以及age，但student相比较来说多了grade，所以分成两部分

def __init__(self, name, age, grade):

super().__init__(name, age)

self._grade = grade

Super().__init__,用以表达父类中的信息,子类本身独有的信息依然使用self.

子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这个就是多态（poly-morphism）。

from abc import ABCMeta, abstractmethod

class Pet(object, metaclass=ABCMeta):

"""宠物"""

def __init__(self, nickname):

self._nickname = nickname

@abstractmethod

def make_voice(self):

"""发出声音"""

pass

class Dog(Pet):

"""狗"""

def make_voice(self):

print('%s: 汪汪汪...' % self._nickname)

class Cat(Pet):

"""猫"""

def make_voice(self):

print('%s: 喵...喵...' % self._nickname)

def main():

pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]

for pet in pets:

pet.make_voice()

if __name__ == '__main__':

main()

在上面的代码中，我们将Pet类处理成了一个抽象类，所谓抽象类就是不能够创建对象的类，这种类的存在就是专门为了让其他类去继承它。Python从语法层面并没有像Java或C#那样提供对抽象类的支持，但是我们可以通过abc模块的ABCMeta元类和abstractmethod包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）。上面的代码中，Dog和Cat两个子类分别对Pet类中的make_voice抽象方法进行了重写并给出了不同的实现版本，当我们在main函数中调用该方法时，这个方法就表现出了多态行为（同样的方法做了不同的事情）。

抽象类的声明:

from abc import ABCMeta, abstractmethod

class Pet(object, metaclass=ABCMeta):

在写抽象类的方法的时候（函数），要先声明：@abstractmethod

@abstractmethod

def make_voice(self):

"""发出声音"""

pass

继承抽象类的格式与继承普通类一样

class Dog(Pet):

案例三.工资结算

"""某公司有三种类型的员工分别是部门经理、程序员和销售员需要设计一个工资结算系统根据提供的员工信息来计算月薪部门经理的月薪是每月固定15000元程序员的月薪按本月工作时间计算每小时150元销售员的月薪是1200元的底薪加上销售额5%的提成"""

(三种人都是员工，都具有名字，工资两个公共属性，构建“员工”这个虚拟类，三种员工进行调用，并都具有自己的额外属性)