第三天

第一部分

动态语言：
    在执行期间，对变量进行类型的赋予
静态语言：
    在编译的时候，就已经对变量的类型进行赋予  java

弱类型：对变量进行绑定的时候，给变量赋予任何类型的数据，
    但是使用不管定义成任何类型的变量，都可以直接做其他类型的变量使用

强类型语言：一旦赋予某一个变量某一种类型之后，
    使用的时候，必须经过转换才能当其他类型数据来用
 a="123"
 print(a+1)
python是动态语言，强类型语言

第二部分 字节、编码与解码

"""
字节（多字节）bytes：由一些列的字节组成的序列
单字节：8位数据位表示一个字节   byte,表示2^8-1=255种不同的内容
"""
1.字节的定义
跟字符串不同的，在前面b
def creace():
    by=b"abc"
    print(type(by))
    print(by)
# by=b"abc中"

2.操作
(1) 操作符, 几乎跟字符串类似
print(b"abc"+b"def")
print(b"abc" == b"abc")
print(b"abc" is b"abc")

(2) 索引
a=b"abc"
print(a[0])
print(a[-1])

(3) 切片:对于不可变类型来说，整切一定是同一个对象
print(a[:] is a)

3.相关方法：几乎跟字符串中一致。

4.编码问题
a="a"
b=b"a"
# 01011010-----二进制-----十进制
# 转换的规则： 字符集： 一组字符组成的集合，目的都是把数据转换成二进制
#  (1) ascii:美国，2^4-1=15, 2^8=255----存储大小写字符，符号 0000000-11111110
#  (2) gb2312,中国，常用的汉字
#  (3) unicode编码，定长存储，存储了所有国家的所有语言。浪费空间。通常是按2字节16位，不常用的4个字节
#  (4) utf-8:变长,utf-8的字符编码部分是ascii重合（小优点） 一般汉字是用三个字节24位来表示
"""
字符 ascii         unicode                  utf-8
A   10000001     00000000 0100000001     01000001
"""
print(ord("A"))
print(chr(65))
print(bin(65))

# 字节和字符串  关系
# 字节使用的是ascii，存不了中文，只支持英文，数字，符号
# 字符串，使用，python  unicode编码
a="abc" # 在显示的时候，使用字符集解析字符串，会一个字符串解析成很多字节

# Unicode 和 utf-8 关系
# 创建记事本 进行编辑的时候，计算机的内存中，使用unicode编码，当真正需要保存到硬盘，或者输出，才转换成utf-8
# 浏览网页，服务器，会动态生成unicode内容，转换成utf-8，传输到浏览器，显示

# 显示某一个字符的存储形式
print("这是中文")
# ord 方法能够查询每一个字符的在计算机中存储的整数形式
print(ord("中"))
print(bin(ord("中")))
print(hex(ord("中")))  # 稍微改动，在前面加u-----就是unicode编码
print("u4e2d")
# encode 能够显示字符，按照指定的编码格式显示存储形式
# 没有参数默认utf-8
print("中国".encode())
print("abc".encode("ascii"))
print("中国".encode("utf-8"))
print("中国".encode("gb2312"))

# 字节和字符串之间的转换
# encode方法： 能够字符串转换成字节-----编码
print("ascii","abc".encode("ascii"))
print("ascii","中国".encode("ascii"))
tybes1="abc中国".encode()
print(tybes1)

# decode方法：能够把字节转换成字符串----解码
bytes2=b"abcxe4xb8xadxe5x9bxbd"
print(bytes2.decode())
# print(bytes2.decode("gb2312"))

# 使用字符串和字节下的方法也可以
b = bytes("abc中国","utf-8") # -----跟encode 类似
print(b)
s=str(b,"utf-8")   # -----跟decode类似
print(s)

# 练习,字节 和字符串之间的转换

# 说明
# and 和 or
print((1 or 2) and 3)
print(1 or (2 and 3))

第三部分 格式化

a=123
print("这是一个数字",123)
# 对人来说友好
print("这是一个数字"+str(123))
# 对于解释器来说是友好的repr
print("这是一个数字"+repr(123))

两种形式
% ：语法：  “字符%[格式]” % (变量1，）
格式化的格式类型,%s或者%r  %f(float)  %d  %o  %x
1. 单纯使用%格式化
print("this is a test %s" % 123)
print("this is a test %s %s" % (123,456))
a=123
print("this is a test %s %s" % (a,456))

2.%n.p  n占位符（至少保留的位数） p截取的字符数
print("%s" % "hello world")
print("%20s" % "hello world")
print("%5s" % "hello world") # 如果实际的位数比格式化之后的多，那么按实际的来
print("%10.2s" % "hello world")
print("%-20s" % "hello world")

3. %d 格式化整数  %f格式化浮点数
print("%d" % 12345)
print("%1d" % 12345)
print("%10d" % 12345)

n.f 保留的小数位数f(n包含小数点）
print("%f" % 3.141592)
print("%.f" % 3.141592)
print("%.2f" % 3.141592)  #保留小数按照四舍五入的形式保留
print("%.20f" % 3.141592)
print("%08.2f" % 3.141592) #多出来的部分可以选用0占位
print("%3.2f" % 3.141592) #n是最少保留位数，多出来，按原来的显示

二、format 格式
1. 格式："字符串{}".format(参数)
print("this is a test{}{}".format("example",123))
# 使用索引形式格式，初始值是0
print("this is a test{1}{0}".format("example",123))
print("this is a test{x}{y}".format(x="example",y=123))

2. 左对齐，右对齐、保留等
< 左对齐    > 右对齐   ^ 中间对齐
使用的时候 索引(参数名)：对齐的方式/保留的位数/格式
print("{} and {}".format("hello","world"))
print("{} and {}".format("hello","world"))
print("{:<10s} and {:>10s}".format("hello","world"))
print("{:^10s} and {:^10s}".format("hello","world"))
取小数
print("{} is {:.2f}".format(3.14159,3.14159))
print("{} is {:>10.2f}".format(3.14159,3.14159))
print("{0} is {1:>10.2f}".format(3.14159,3.14159))

第四部分 控制流程

"""
控制流程：
顺序：按部就班的执行
选择：根据条件执行不同的代码段
循环：重复执行
"""
缩进 python 只能使用空格来表示缩进，表示不同的代码级别
#代码1
#  代码2
#     代码3

 一、选择判断
# if:当条件成立的时候，执行代码段
score=60
if score>60:
    print("我及格了")
    print("我可以不用交挂科费了")
print("if条件之外的代码，跟if没有关系")

# else:else后面没有条件，if条件不成立时候执行的代码块
if score>60:
    print("我及格了")
    print("我可以不用交挂科费了")
else:
    print("我需要交500块钱")
print("if条件之外的代码，跟if没有关系")

# 多分支 elif 条件：if条件不成立，再符合其他条件时执行的代码段，多选一
# 注意： else、elif在条件选择时候，不能没有if，但if可以单独存在
if 80>=score>60:
    print("我及格了")
    print("我可以不用交挂科费了")
elif 90>=score>80:
    print("我已经达到了“良”")
elif 100>=score>90:
    print("我已经达到了“优秀”")
else:
    print("我需要交500块钱")
print("if条件之外的代码，跟if没有关系")

# 条件选择顺序安排，可能性大的放在if，elif前面
# elif，当满足了if条件，或者前面还有其他的elif符合条件，那么不会执行下面elif了。
score=61
if score>20:
    print(">20")
elif score>30:
    print(">30")
elif score>40:
    print(">40")

二、布尔类型的转换：任意一个数据类型都能转换成布尔类型bool（）显式，也可以通过隐式转换
#          True           False
# int      非0             0
# float    非0.0           0.0
# complex  非0j            0j
# str      至少有一个元素   空序列（没有元素）
# None     转换            False
if "abc":
    print("aaaaa")

三、三元表达式
x=1
y=10
if x<y:
    print("判断正确")
else:
    print("判断错误")
# 格式：[if成功后执行的表达式的结果]  if 条件  else [if不成的表达式的结果]
x=1
y=10
print("判断正确") if x<y else  print("判断错误")
# 应用：对于简单的if else 的判断 定义x 如果0 输出男，否则女
print("男" if x==0 else "女")

# 练习 判断输入休息日还是工作日，d=1-5  工作日  6-7  休息日
d=int(input("请输入星期几(1-7)："))
# print("工作日" if 0<d<6 else "休息日")
print("工作日" if 0<d<6 else ("休息日" if 6<=d<=7 else "输入错误"))
# 使用三元表达式，如果程序逻辑简单，使用，否则不要使用，可读性差


四、断言：断定某些语句是否正确，调试程序使用
# 语法： assert 表达式，错误信息
# 在执行断言时，如果值转成bool之后，False，会产生错误
a="abc"
assert a=="bcd","a是abc,不是bcd判断出错"
print("其他的代码块")


五、循环
1. while循环
# True 1==1
# 格式 while 条件：
#            循环体
# 计算1+2+...+100
i=1
sum=0
while 1<=100:
    sum+=i
    i+=1  # 为了给i进行+1，控制循环次数。如果不控制i则变成了永久循环。
print(sum)

# 猜数字：如果猜错了，输入一个y，可以重新重新猜，输入一个n，结束
import random
x=random.randrange(10)
i = int(input("请输入一个数字："))
while x!=i:
    if x<i:
        print("猜大了，小一点")
    else:
        print("猜小了，大一点")
    t=input("是否继续猜（y是，n退出）：")
    if t=="n":
        i=x
    else:
        i=t
2.for 循环
# 格式： for 每一个元素变量 in 迭代对象：
#            迭代体
# 1+...=100
# 函数 range(start,end，step) 产生送start 开始到end (不包含end)的列表
# step的默认值1（从左到右），如果是负值（从右到左)
# [1,2,3,4,5....100]
s=0
for i in range(1,101):
    s+=1
    print(s)
s=0
for i in range(1,101,2):
    s+=i
    print(i)
print(s)
s=0
for i in range(99,0,-2):
    s+=i
    print(i)
print(s)

3、for 循环的嵌套
# 格式
# for 变量 in 外循环迭代(1,2,3):
   # for 变量 in 内循环迭代对象(1,2,3,4)：
   #      迭代体

# 在一行中打印6个小星星
# j=元素
for j in range(6):
    print("*",end="")
# 输出10行，每行都是6个小星星
for i in range(10):
    for j in range(6):
        print("*",end="")
    print()

# 遍历字符串元素，使用for，while分别做


4、 跳出循环
# break 和continue
# break，跳出整个循环
for i in range(1,1000):
    print(i)
    if i==3:
        print("已经找到了3")
        break
# continue 跳出本次循环
# 输出1-19之间所有的数，标注偶数
for i in range(1,20):
    if i%2==0:
        print("这是一个偶数{}".format(i))
        continue
    print("这个数是{}".format(i))
# 从逻辑上来说，break和continue不能无条件的使用。


5、在循环之后使用else 在循环迭代正常完成之后执行的代码段
# 容易被误解
for i in range(3):
    print(i)
else:
    print("dddd")
# 不正常解释循环迭代的时候可以使用else，来完成for不执行的代码段
# 如果循环没有因为break而提前结束，就会执行else
for i in range(3):
    if i == 2:
        print(i)
else:
    print("没找到")

# 判断是不是质数
i=int(input("输入一个数："))
for j in range(2,i):
    if i%j==0:
        print("这不是一个质数")
        break
else:
    print("这是一个质数{}".format(i))

6、 enumerate #可以获得元素和对应的索引
a = "abcd"
for i in a:
    print(a)
for j in range(len(a)):
    print(j)
for index,i in enumerate(a):
    print(index)
    print(i)