第四天

1.数值类型(部分):

布尔类型，整型，浮点型。

整型：python的整型结合了整型和长整型。所以python很方便进行大数运算。

浮点型：小数类型，python区分整型和浮点型根据小数点。有小数点是浮点型，没有小数点是整型。

布尔类型：表示真(True)，假(False)。也是一种特殊的整形。True=1,False=0. (python中可以把True 和False当作1和0参与计算。但是实际上是不妥的。不要在实际应用中这样做。)

2.e记法(科学计数法)：

用来表示特别大或者特别小的数。

eg：a=0.0000000000000000000000000025

print(a)

2.5e-27

eg：1.5e11

150000000000.0

15e10

150000000000.0

3.数据类型转换：

3.1. 转换为字符串：str()

3.2. 转换为整数：int()

3.3. 转换为浮点型：float()

3.1.1 字符串转换为整数的时候字符串必须是数字。无法完成 int('小甲鱼') 会报错。

eg： str(5.99) 的结果为'5.99';

str(5e19) 的结果为：'5e+19';

3.2.1 python处理浮点型转化为整数的时候是正数是向下取整的。对于负数则刚好相反 —— 是向上取整。

eg： int(5.99) 的结果为5 ;

3.2.2 四舍五入的简易写法：int(x+0.5)

“四舍五入”结果为：5，int(5.4+0.5) == 5

“四舍五入”结果为：6，int(5.6+0.5) == 6

3.3.1 转化浮点型的时候：

eg： float('520') 的结果为 520.0;

float(520) 的结果为: 520.0;

4.获取关于类型的信息

4.1 type()

eg: type('520') 的结果为

type(520) 的结果为

type(True) 的结果为

type(5e15) 的结果为 注：e记法就是浮点型的一种。

4.2 isinstance()

isinstance('520',str) #两个参数，第一个为要判断类型的内容或者变量，第二个为要判断的类型。如果内容或者变量符合对应的类型则返回 True 反之返回 False。

4.3 对于 type() 和 isinstance() 建议使用 isinstance()，因为它的返回结果比较直接，另外 type() 其实并没有你想象的那么简单

5.Python3 可以给变量命名中文名

Pyhton3 源码文件默认使用utf-8编码(支持中文)。

6.isdigit

Python中 isdigit() 方法检测字符串是否只由数字组成。

s 为字符串

s.isalnum()   所有字符都是数字或者字母，为真返回 True，否则返回 False。

s.isalpha()所有字符都是字母，为真返回 True，否则返回 False。

s.isdigit()所有字符都是数字，为真返回 True，否则返回 False。

s.islower()所有字符都是小写，为真返回 True，否则返回 False。

s.isupper()所有字符都是大写，为真返回 True，否则返回 False。

s.istitle()  所有单词都是首字母大写，为真返回 True，否则返回 False。

s.isspace()所有字符都是空白字符，为真返回 True，否则返回 False。

例如：

>>> s = 'I LOVE FISHC'

>>> s.isupper()

>>> True

7. 补充知识点

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数                          描述

int(x [,base])              将x转换为一个整数

long(x[, base] )          将x转换为一个长整数

float(x)                       将x转换到一个浮点数

complex(real[, imag]) 创建一个复数

str(x)                          将对象 x 转换为字符串

repr(x)                        将对象 x 转换为表达式字符串

eval(str)                      用来计算在字符串中的有效Python表达式,并返回一个对象/td][/tr]

tuple(s)                       将序列 s 转换为一个元组

list(s)                          将序列 s 转换为一个列表

set(s)                         转换为可变集合

dict(d)                        创建一个字典。d 必须是一个序列(key, value)元组。

frozenset(s)               转换为不可变集合

chr(x)                         将一个整数转换为一个字符

unichr(x)                    将一个整数转换为Unicode字符

ord(x)                         将一个字符转换为它的整数值

hex(x)                        将一个整数转换为一个十六进制字符串

oct(x)                         将一个整数转换为一个八进制字符串

8.改进游戏

importrandom

times= 3secret= random.randint(1,10)print('------------------猜猜猜------------------')

guess=0print("不妨猜一下我现在心里想的是哪个数字：", end=" ")while (guess != secret) and (times >0):

temp=input()iftemp.isdigit():

guess=int(temp)if guess ==secret:print("我草，你是我心里的蛔虫吗？！")print("哼，猜中了也没有奖励！")else:if guess >secret:print("哥，大了大了~~~")else:print("嘿，小了，小了~~~")if times > 1:print("再试一次吧：", end='')else:print("机会用光咯T_T")else:print("抱歉，您的输入有误，请输入一个整数：", end='')

times= times - 1 #用户每输入一次，可用机会就-1

print("游戏结束，不玩啦^_^")

第五天

1.算数操作符：

+ - * / % ** //

加 减 乘 除 取余 幂运算 地板除

2. 加减乘除 地板除

eg：a = 5

a = a +3

a += 3

a = 11

b = 3

b -= 1

b = 2

a = b = c = d = 10

a += 1 a=11

b -= 3 b=7

c *= 10 c=100

d /= 8 d=1.25

地板除法：整数除以整数，默认返回一个整数类型。(向下取整)也就是丢掉多余的小数。

在python3除法已经是真正的除法了，/是直接的除法不再是地板除法。在python中 //执行的则是地板除法。

地板除法例子：

eg：

10//8 #结果是1

3.0//2 #结果是1.0

3. %求余：

eg：

5%2 #结果是1

11%2 #结果是1

4. **幂运算：

eg：

3**2 #结果是9

3**5 #结果是243

5.优先级问题：

所以先乘除后加减遇到括号里的先算括号里面的。

eg：-3 * 2 + 5 / -2 -4 #结果是-12.5

比较操作符比逻辑操作符优先级高

eg：3 <4 and 4 < 5 #结果是True

- 被当做负号使用的时候是一元操作符(单目操作符)

幂运算操作符比其左侧的一元操作符优先级高，比其右侧的一元操作符优先级低。

eg： -3 ** 2 #结果是-9

-(3 ** 2) #上式解释为本式

3 ** -2 #结果是0.1111111111111111

3 ** (-2) #上式解释为本式

6.比较操作符：

7.逻辑操作符：

and：左侧右侧同时为真。(True)则结果为真(True)。

or ：只需要左边或者右边两边任意一边为真(True)那么结果为真(True)。两边同时为假(False)时，结果才为假(False)。

not：操作符是一元操作符。只有一个操作数，做取反操作。

eg：not False #结果是True

not True #结果是False

not 0 #结果是True

not 4 #结果是False (非0的数默认为True)

在python还可以这样写：

eg：3 < 4 < 5 #结果是True

被解释为：3 < 4 and 4 < 5

逻辑操作符优先级 not > and >or 。

第六天

0.了不起的分支和循环

判断：该不该做某事。if else

循环：持续的做某事。while

1.

● —按照100分制，90分以上成绩为A，80到90为B，60到80为C，60以下为D,写一个程序，当用户输入分数，自动转换为ABCD的形式打印。

● 解题方案:

一method1.py

一method2.py

一method3.py

method1.py :

score = int(input('请输入一个分数：'))if 100 >= score >= 90:print('A')if 90 > score >= 80:print('B')if 80 > score >= 60:print('C')if 60 > score >=0:print('D')if score < 0 or score > 100:print('输入错误！')

method2.py:

score = int(input('请输入一个分数：'))if 100 >= score >= 90:print('A')if 90 > score >= 80:print('B')if 80 > score >= 60:print('C')if 60 > score >=0:print('D')if score < 0 or score > 100:print('输入错误！')

method3.py:

score = int(input('请输入一个分数：'))if 100 >= score >= 90:print('A')if 90 > score >= 80:print('B')if 80 > score >= 60:print('C')if 60 > score >=0:print('D')if score < 0 or score > 100:print('输入错误！')

比较 method1.py，method2.py，method3.py 的优劣势

逻辑上： method2.py==method3.py

elif == else if

体现了：python两大特性：简洁，可读性好

method1.py 把输入的值判断五次，事实上如果输入的是 98，输出 A，后面的完全可以不用再判断了。判断后面四次完全是在浪费 CPU 的时间。

method2.py ， method3.py 的效率是 method1.py 的4倍。

2. Python可以有效避免“悬挂else”

● 什么叫“悬挂else”?

● 我们举个例子，初学C语言的朋友可能很容易被以下代码欺骗:

if ( hi > 2)if ( hi > 7)

printf(“好棒!好棒!”);elseprintf(”切~”);

看起来下面的 else 应该是和 if ( hi > 2 ) 匹配。但是实际上 C 语言有就近匹配原则，下面的 else 应该和 if ( hi > 7 ) 相匹配。

而 python 没有悬挂 else 的问题。

python 强制规定必须要正确对齐缩进否则无法运行，python 让程序员决定 else 属于哪个 if。

通过限制选择，减少不确定性。

3. 条件表达式(三元操作符)

● 有了这个三元操作符的条件表达式，你可以使用一条语句来完成以下的条件判断和赋值操作:

x , y = 4 , 5

if x

small=Xelse:

small= y

● 例子可以改进为:

small = x if x < y else y

语法：x if 条件 else y

三元操作符(三目操作符)实际上是看这个操作符有几个操作数。

赋值号有两个操作数就是二元操作符。

减号只有一个操作符就是一元操作符。

三元操作符就是有三个操作数。

(818)python作者推崇简洁的编程理念，很长一段时间python没有三元操作符概念，他觉得三元操作符会使得程序结构变得非常复杂。

但是 python 社区小伙伴表达了极大的诉求，所以最后还是加上了。大概是2.5的时候加入的。

4. 断言(assert)

● assert 这个关键字我们称之为“断言”， 当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。

举个例子:

>>> assert 3 > 4

● 一般来说我们可以用 Ta 在程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。

与其让错误的条件导致程序后面会出现莫名其妙的 bug 或者崩溃不如在错误条件出现的时候自爆并捕捉合理的处理。

第七天

0. while 循环

while 条件：

循环体

注：在条件为真的时候执行某一段指定的代码。直到条件为假。

1. for 循环

● 虽然说 Python 是由 C 语言编写而来的，但是 Ta 的 for 循环跟 C 语言的 for 循环不太一样，Python 的 for 循环显得更为智能和强大!

● 语法:

for 目标 in 表达式:

循环体

注：python 的 for 循环可以调用迭代器的 next() 方法，会自动的去捕获StopIteration()这个异常，并结束循环。

小甲鱼提到的以后会讲的：'列表'，‘元组’。

标准数据类型：

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

● Numbers(数字)

● String(字符串)

● List(列表)

● Tuple(元组)

● Dictionary(字典)

2. 例子：

0.

favourite='FishC'

for i infavourite:print(i,end=' ')#结果：F i s h C

1.

member=['子鹿','小布丁','黑夜','迷途','怡静']for each inmember:print(each,len(each))#结果：子鹿 3#小布丁 3#黑夜 2#迷途 2#怡静 2

3. range()

● 语法: range( [strat,] stop[, step=1] )

— 这个BIF有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。

— step=1 表示第三个参数的值默认值是1。

— range这个 BIF 的作用是生成一个从 start 参数的值开始到 stop 参数的值结束的数字序列。

4. 例子：

1.

range(5)#结果：range(0, 5)

2.

list(range(5))#结果：[0, 1, 2, 3, 4]

3.

for i in range(5):print(i)#结果：0#1#2#3#4

4.

for i in range(2,9):print(i)#结果：2#3#4#5#6#7#8

5.

for i in range(1,10,2):print(i)#结果：1#3#5#7#9

6.

for num in range(10,20): #迭代 10 到 20 之间的数字

for i in range(2,num): #根据因子迭代

if num%i == 0: #确定第一个因子

j=num/i #计算第二个因子

print ('%d 等于 %d * %d' %(num,i,j))break #跳出当前循环

else: #循环的 else 部分

print (num, '是一个质数')#结果：10 等于 2 * 5#11 是一个质数#12 等于 2 * 6#13 是一个质数#14 等于 2 * 7#15 等于 3 * 5#16 等于 2 * 8#17 是一个质数#18 等于 2 * 9#19 是一个质数

4. 补充知识点：字符串格式化

1.字符串

print ("His name is %s"%("Aviad"))#结果 His name is Aviad

2.整数

print ("He is %d years old"%(25))#结果 He is 25 years old

3.浮点数

print ("His height is %f m"%(1.83))#结果 His height is 1.830000 m

4.浮点数(指定保留小数点位数)

print ("His height is %.2f m"%(1.83))#结果 His height is 1.83 m

5.占位符宽度

print ("Name:%10s Age:%8d Height:%8.2f"%("Aviad",25,1.83))#结果 Name: Aviad Age: 25 Height: 1.83

6.占位符宽度(左对齐)

print ("Name:%-10s Age:%-8d Height:%-8.2f"%("Aviad",25,1.83))#结果 Name:Aviad Age:25 Height:1.83

7.指定占位符(只能用0当占位符？)

print ("Name:%-10s Age:%08d Height:%08.2f"%("Aviad",25,1.83))#结果 Name:Aviad Age:00000025 Height:00001.83

8.科学计数法

format(0.0015,'.2e')#结果 '1.50e-03'

9.词典来传递真实值

print ("I'm %(c)s. I have %(l)d yuan." % {'c':'hungry','l':22})#结果 I'm hungry. I have 22 yuan.

格式符

格式符为真实值预留位置，并控制显示的格式。格式符可以包含有一个类型码，用以控制显示的类型，如下:

%s 字符串 (采用str()的显示)

%r 字符串 (采用repr()的显示)

%c 单个字符

%b 二进制整数

%d 十进制整数

%i 十进制整数

%o 八进制整数

%x 十六进制整数

%e 指数 (基底写为e)

%E 指数 (基底写为E)

%f 浮点数

%F 浮点数，与上相同

%g 指数(e)或浮点数 (根据显示长度)

%G 指数(E)或浮点数 (根据显示长度)

%% 字符"%"

可以用如下的方式，对格式进行进一步的控制：

%[(name)][flags][width].[precision]typecode

(name)为命名

flags可以有+,-,' '或0。+表示右对齐。-表示左对齐。' '为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填充。

width表示显示宽度

precision表示小数点后精度

比如：

print("%+10x" % 10)

print("%04d" % 5)

print("%6.3f" % 2.3)

上面的width, precision为两个整数。我们可以利用*，来动态代入这两个量。比如：

print("%.*f" % (4, 1.2))

Python实际上用4来替换*。所以实际的模板为"%.4f"。

总结:

Python中内置的%操作符可用于格式化字符串操作，控制字符串的呈现格式。Python中还有其他的格式化字符串的方式，但%操作符的使用是最方便的。

5. 两个关键的语句：

1. break：终止当前循环。跳出循环体。

eg：

bingo = '子鹿是帅哥'answer= input('请输入子鹿最想听的一句话：')whileTrue:if answer ==bingo:breakanswer= input('抱歉，错了，请重新输入(答案正确才能退出游戏)：')print('哎呦，帅哦~')print('您真是子鹿肚子里的蛔虫啊^_^')

2. contiune:终止本轮循环并开始下一轮循环。

注：开始下一轮循环之前会判断循环条件，如果成立则开始下一轮循环。否则退出循环。

eg：

for i in range(10):if i%2 !=0:print(i)continuei+=2

print(i)#结果：2#1#4#3#6#5#8#7#10#9