Python基础语法
1，编程语言介绍
机器语言：
由于计算机内部只能接受二进制代码，所以用二进制代码0或1来描述指令，而由这些指令组成的机器指令集合构成计算机的机器语言。
二级制代码 > 机器指令 > 机器语言
汇编语言：
实质和机器语言是相同的，都是直接对硬件操作，只不过指令采用英文缩写的标识符，更容易识别和记忆。
二级制代码 > 机器指令 > 英文标识符 > 机器语言
高级语言：
对于程序员更加友好，不同高级语言之间的本质的区别就是转换成二进制的方式不同来确定的。高级语言所编制的程序不能直接被计算机识别，必须经过转换才能被执行。
按照转换方式(转换成二进制)可将他们分为两类：
编译型
指在应用源程序执行之前，将程序源代码转换成目标代码，因此其目标代码可以脱离其语言环境独立执行。使用方便，效率更高，但是应用程序一旦修改，须先修改源代码，再重新编译生成新的目标文件才能执行。
编译后程序运行时不需要重新翻译，直接使用翻译的结果就行。编译型程序运行效率高，运行快，不依赖语言运行环境，跨平台性差。如C、C++、GO、Delphi等。
解释型
应用程序源代码一边由相应语言的解释器翻译成目标代码，一边执行，开发效率高，运行效率低，且不能生成二进制文件，应用程序不能脱离其解释器。如Python、Java、PHP、Ruby等。解释型开发效率高，跨平台性好，运行效率低，依赖解释器运行。
编译型程序运行效率高，速度快，不依赖语言运行环境，跨平台性差。
解释型开发效率高，运行效率低，跨平台性好，依赖解释器运行。
2，Python介绍和安装
Python简介：
Python创始人：Guido van Rossum（龟叔：荷兰人）Python诞生在1989年圣诞。
1991年，第一个公开发行版发行。
2004年11月，诞生python2.4，同年诞生Django。
2008年12月，出现Python3.0
2010年7月，出现一个过渡版本Python2.7
2014年11月，最多只支持到2020年，之后不支持2.0版本
Python解释器类型：
Python解释器是用C语言写的
Python解释器种类有：CPython、IPython、PyPy、Jython、IronPython，其中pypy更快一点。
Python的安装：打开官网下载中心
测试安装是否成功：
windows-->运行-->输入cmd,回车（或者直接同时按住win键+R键，输入cmd），弹出cmd程序，输入Python，如果进入交互环境，代表安装成功。
你好print('hello world!')
保存为helloworld.py,注意.py后缀名的作用：命名约束规范，方便程序员识别代码。
进入cmd命令行，执行Python helloworld.py，看结果。
注意文件名前面加python的原因是要把代码交给python解释器去解释执行
内存和磁盘的关系：内存存取速度快，断电就丢失；磁盘存取速度慢，永久保存
Python交互器是主要来对代码进行调试用的
3，变量(Variables)
变量
变量：先定义后使用
变量作用：标记并存储数据， 增强可读性。能被后面的代码调用，数据复用（一个数据能被多次使用）。
声明变量：变量名=变量的值
变量的命名规则：
1.变量名只能是数字、字母或下划线的任意组合
2.变量名的第一个字符不能是数字
3.以下关键字不能声明为变量名
'and','as','assert','break','class','continue','def','elif','else','with', 'yield','except','exec','finally','for','from','global','if','import', 'in','is', 'lambda','not','or','pass','print','raise','return','try','while',
变量在python里面是按引用传递，底层是C(指针即地址(内存条的位置))
一夫(数据)多妻（变量），也即一个变量只能相对应一个数据，但是一个数据可以被多个变量所指向。
字面量(不同语言的字面量的类型不同)：在Python中，对字面常量（数字、字符串、布尔、字节）对象进行缓存，
多个变量赋相同值，其实是同一个值。
变量与内存：用编程思维进行理解，了解变量与内存的关系可以减少编码的bug，减少地址和内存的错误。
常量
常量：程序在执行过程中不能改变的量
在Python中没有一个专门的语法代表常量，程序员约定俗成的变量名全部大写代表常量。
4，用户交互和注释
读取用户输入
name = input(" what's your name:")
print("hello " + name )
输入用户姓名和密码
username= input("username:")
password= input("password:")
print(username, password)
注释:解释说明，帮助阅读代码。
单行注视：# 被注释内容
多行注释：""" 被注释内容 """
5，数据类型
判断字符串是何种类型
type(字符串) # 这里的字符串只能判断一种类型，不能一起判断多种字符串类型。
<class '这里显示该字符串类型'>
基本数据类型
1、数字
int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
float（浮点型）：浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的
关于小数不精准问题 Python默认的是17位精度,也就是小数点后16位，尽管有16位，但是这个精确度却是越往后越不准的。 首先，这个问题不是只存在在python中，其他语言也有同样的问题 其次，小数不精准是因为在转换成二进制的过程中会出现无限循环的情况，在约省的时候就会出现偏差。 比如：11.2的小数部分0.2转换为2进制则是无限循环的00110011001100110011... 单精度在存储的时候用23bit来存放这个尾数部分（前面9比特存储指数和符号）；同样0.6也是无限循环的； 这里有一个问题，就是当我们的计算需要使用更高的精度（超过16位小数）的时候该怎么做呢？ #借助decimal模块的“getcontext“和“Decimal“ 方法 >>> a = 3.141592653513651054608317828332 >>> a 3.141592653513651 >>> from decimal import * >>> getcontext() Context(prec=50, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[FloatOperation], traps=[InvalidOperation, DivisionByZero, Overflow]) >>> getcontext().prec = 50 >>> a = Decimal(1)／Decimal(3)#注，在分数计算中结果正确，如果直接定义超长精度小数会不准确 >>> a Decimal('0.33333333333333333333333333333333333333333333333333') >>> a = '3.141592653513651054608317828332' >>> Decimal(a) Decimal('3.141592653513651054608317828332') #不推荐：字符串格式化方式，可以显示，但是计算和直接定义都不准确，后面的数字没有意义。 >>> a = ("%.30f" % (1.0/3)) >>> a '0.333333333333333314829616256247'
2，字符串类型
字符串：在Python中，加了引号的字符都被认为是字符串！
注意：单双引号是没有任何区别的，如果遇到字符串中有单引号，此时要用双引号表明字符串；多行字符串必须用多引号。如果字母不加引号，会被认为是变量(此时变量还未赋值)，报错。
字符串拼接：字符串能进行“相加”和“相减”运算。但是注意，字符串的拼接只能是双方都是字符串，不能跟数字或者其他类型拼接单双引号。
3，布尔类型：
只有两个值True、False ，主要用来做逻辑判断。True才进入，当0，False和None的时候为False。
基本数据类型：数据集
1，列表
列表是一个数据的集合，[ ] 内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素，可对集合进行方便的增删改查操作
列表的创建
list_test=['张三','李四','alex']
#或
list_test=list('alex')
#或
list_test = list(['张三', '李四', 'alex'])
列表的特点和常用操作
特性：
1.可存放多个值
2.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序
3.可修改指定索引位置对应的值，可变
常用操作：
索引，查找，切片，统计，追加，插入，修改，删除，显示长度，是否包含，for循环，range生成表，排序，反转，合并，拷贝
列表常用操作 #索引,查找元素。 >>> l = ['a', 'b', 'd', 'd','c', 'f', 'e', '1', ' ','3', '3','3','2'] >>> l[2] 'd' >>> l[1] 'b' #查找列表里面某元素的索引值（如果有重复，只出现最左边的那个，因为是从左到右的） >>>l,index(d) #统计列表里面有多少个重复的元素 >>>l.count(3) #切片,顾头不顾尾，[0:2]表示第0，1个元素。 >>> l = ['a', 'b', 'd', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] >>> l[0:3] ['a', 'b','d'] >>> l[2:5] ['d', 'd', 'c', 'f'] >>> l[:3] ['a', 'b', 'd'] >>> l[2:] ['d', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] >>> l[:] ['a', 'b', 'd', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] >>> l[::2] #间隔取值 ['a', 'd', 'c', 'e',' ', '3','2'] >>>l[2:10:2] ['d', 'c', 'e', ' '] >>>l[-4:] ['3', '3','3','2'] #追加,在列表的最后一个位置添加进元素 >>> l.append("e") >>> l l = ['a', 'b', 'd', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] #插入 >>>l.insert(0,'m') >>>l ['m', 'a', 'b', 'd', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] #修改 >>>l[2] = 8 >>>l ['m', 'a', '8', 'd', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] #删除,remove,pop,del >>> l.remove('d') #可以自主删除哪一个元素 >>> l ['m', 'a', '8', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3', '2'] >>> l.pop() #删除列表最后一个元素 '2' >>> l ['m', 'a', '8', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3'] >>>del l[2] #全局删除东西，想删什么就删什么。 >>>l ['m', 'a', 'd', 'c', 'f', 'e', '1', ' ', '3', '3', '3'] #长度 >>> len(l) #包含 >>> 'd' in l True >>> 'h' in l False #for循环,有边界，把列表里面的每个元素分别赋值给i然后去执行。 >>> for i in l: print(i)#后面结果逐个将l中的元素打印出来 #利用range生成一个列表 >>>range(10) #生成一个0-9的列表 range(0,10) #排序，不支持int和str一起排序 >>>n = ['a', 'c', 'b', 'e', 'd', 'g', 'f'] >>>n ['a', 'c', 'b', 'e', 'd', 'g', 'f'] >>>n.sort() >>>n ['a', 'b', 'c', 'd', 'e', 'f', 'g'] #这里出现排序结果，其结果是按照ASCII表进行排序 #反转一个列表 n = ['g', 'f', 'e', 'd', 'c', 'b', 'a'] >>>n.reverse() >>>n ['a', 'b', 'c', 'd', 'e', 'f', 'g'] #合并两个列表 >>>n2 = ['extend', 'gradon'] >>>n.extend(n2) n = ['g', 'f', 'e', 'd', 'c', 'b', 'a', 'extend', 'gradon'] >>>n + n2 #将n和n2列表进行合并，拼接在后面 #拷贝，copy,生成另外一个完全独立的列表 >>>n3 = ['a','b','c'] >>>n4 = n3.copy() >>>n4 ['a','b','c'] #这里变量不像str里面的赋值，改变一个列表，另一个列表同时改变，但是利用上面的copy可以做到独立 >>>n = ['g', 'f', 'e', 'd', 'c', 'b', 'a'] >>>n5 = n >>>n[2] e >>>n[2] = 2 >>>n ['g', 'f', '2', 'd', 'c', 'b', 'a'] >>>n5 ['g', 'f', '2', 'd', 'c', 'b', 'a']
制作一个简单购物车
#现有如下商品 #products = [['iphone8', 6888], ['MacPro', 1488], ['小米', 2499], ['coffe', 31], #['Book', 80], ['Nike', 799]] #打印出如下格式 #------------------商品列表------------------- #0. iphone8 6888 #1. MacPro 1488 #2. 小米 2499 #3. coffe 31 #4. Book 80 #5. Nike 799 #写一个循环，不断的问用户想买什么，用户选择一个商品编号，就把对应的商品添加到购物车里面，最终用户输入q退出时，打#印购物车里的商品列表。 # -*- coding: utf-8 -*- products = [['iphone8', 6888], ['MacPro', 1488], ['小米', 2499], ['coffe', 31], ['Book', 80], ['Nike', 799]] shopping_cart = [] # run_flag = True # 标志位 exit_flag = False while not exit_flag: print("------------------商品列表-------------------") for index, p in enumerate(products): print("%s. %s %s" % (index, p[0], p[1])) choice = input("输入想买的商品编号：") if choice.isdigit(): choice = int(choice) if choice >= 0 and choice < len(products): shopping_cart.append(products[choice]) print("Added product %s into shopping cart." % (products[choice])) else: print('商品不存在') elif choice == 'q': if len(shopping_cart) > 0: print("------------你已购买一下商品--------------") for index,p in enumerate(shopping_cart): print("%s. %s %s" % (index, p[0], p[1])) # break # run_flag = False exit_flag = True shopping_cart
列表与字符串
split和join，分割和连接
#分割 >>> s = 'hello world' >>> s.split(' ') ['hello', 'world'] >>> s2= 'hello,world' >>> s2.split(',') #连接 >>> l = ['hi','eva'] >>> '!'.join(l) 'hi!eva'
2，元组
对于列表来说，两者差不多，也是存一组数，但是一旦创建，便不能修改，主要是用来读，所以又叫做只读列表。
定义：
与列表类型比，只不过[]换成()
age=(11,22,33,44,55) 本质age=tuple((11,22,33,44,55))
特性：
不可变，元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以修改。
功能：
index，count，切片
使用场景：显示的告知别人，此处数据不可修改；数据库连接配置信息等
hash函数
hash，一般翻译为“散列”，也有直接翻译为“哈希”的，就是把任意长度的输入，通过散列算法，变成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值，简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
特征：hash值的计算过程是依据这个值的一些特征计算的，这就要求被hash的值必须固定，因此被hash的值必须是不可变的（数字，字符串，元组）。简单来说，可以利用hash函数来生成一段固定的值。（如果不能保证输出的数据唯一的，容易造成冲突）
用途：文件签名；md5加密(如账号密码)；密码验证
>>> hash("abc") -6784760005049606976 >>> hash((1,2,3)) 2528502973977326415
3，字典
作用：存多个值,key-value存取，取值速度快
定义：info = {}
key必须是不可变类型，value可以是任意类型
info={'name':'egon', 'age':18, 'sex':'male'} #本质info=dict({....})
或
info=dict(name='egon',age=18,sex='male')
或
info=dict([['name','egon'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)
习惯使用第一，第二种方法进行创建。
特点：1.key-value结构，key必须是可hash、必须是不可变数据类型、必须唯一
2.每一个key必须对应一个value值，value可以存放任意多个值，可修改，可以不唯一
3.字典是无序的
4.字典的查找速度快是因为字典可以把每个key通过hash变成一个数字（数字是按照ASCII码表进行排序的）
使用方法：
增删改查循环长度,多重嵌套
# 语法 info = { 'st0': "yangmian", 'st1': "liuzhenhua", 'st2': "yaolaoban" } print(info) # {'st0': 'yangmian', 'st1': 'liuzhenhua', 'st2': 'yaolaoban'} # 增加 info['st3'] = 'zhangliang' print(info) # {'st0': 'yangmian', 'st1': 'liuzhenhua', 'st2': 'yaolaoban', 'st3': 'zhangliang'} # 修改 info['st0'] = 'fangxuezhen' print(info) # {'st0': 'fangxuezhen', 'st1': 'liuzhenhua', 'st2': 'yaolaoban', 'st3': 'zhangliang'} # 查找 print('st0' in info) # 标准用法，判断在没在里面,若有，则返回True # Ture print(info.get('st0')) # 获取，最常用方法 # fangxuezhen print(info['st3']) # 获取 不存在则会报错 # zhangliang # 对于这种方法，如果一个key不存在，就报错，get不会，不存在只返回None. # 删除 info = {'st0': 'fangxuezhen', 'st1': 'liuzhenhua', 'st2': 'yaolaoban', 'st3': 'zhangliang'} info.popitem() # 随机删除一个key info.pop('st2') # 删除key del info['st0'] # 删除的key ，如果没有删除的key 就报错 KeyError: 'student01' print(info) # {'st1': 'liuzhenhua'} info.clear() # 清空字典 print(info) # {} # 多级字典嵌套 dic1 = { "a": {"aa": 'aaa'}, "b": {"bb": 'bbb'} } print("-------其他方法-------") # 其他方法 info = { "name1": ['xu', 22], "name2": ['liu', 23], "name3": 'wu' } info2 = { "name1": 'yang', "name4": 'yao', 1: 2 } info.keys() # 打印所有的key info.values() # 打印所有的value info.items() # 把字典转成一个列表 info.update(info2) # 把两个字典合成一个,如果有重复的key ，info2里边的重复key会覆盖info里边的key info.setdefault("name", "wu") # 设置一个默认的key:value , # 如果info字典里没有name这个key，那么info字典里有添加 name:wu # 如果info字典里存在了key:value，那么新添加的name:wu就失效了 print(info.fromkeys(["name5", "name6"], "我是重复的value")) # 从一个可迭代的对象中批量生成key和相同的value # 字典的循环:高效循环 for k in info: print(k, info[k]) # 打印key value # 另外一种方法 低效 for k, v in info.items(): # 先把字典转成列表，在循环，所以低效 print(k, v) dictionary-ways
可以这样创建一个字典
# 可以这样创建一个字典
d = {}
for i in range(10):
d[i] = i - 50
print(d)
# 执行结果
# {0: -50, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
4，集合
集合是一个无序的、不重复的数据组合
作用：1.去重，一个列表变成集合，就自动去重了。
2.关系测试，测试两组数据之间的交集、差集、并集等关系
语法：
s = {} #如果为空，就是字典
s = {1,2,3,4} # 就成了集合 set
s = {1,2,3,4,1,2} # 有重复数据，显示结果就直接去重{1, 2, 3, 4}
列表转成给一个集合
list = [1, 2, 3, 4, 1, 2]
list2 = set(list)
集合的方法
增删改查，集合关系测试（交集，差集，并集，包含，相交）
s = {1, 2, 3, 5, 4, 6, 9, 8, 7}
print(s)
# 增加,只能添加一个值，update可以添加多个值
s.add(10)
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
# 三个删除
# 删除指定元素，常用，若集合中无此元素，则报错
s.remove(10)
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 删除元素，与remove相比，如果集合中没有这个元素，则不会报错
s.discard(10)
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# 随机删除,不常用
s.pop()
print(s) # {2, 3, 4, 5, 6, 7, 8, 9}
# 联合其他集合，也可添加多个值
s.update({1, 10})
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
s2 = {11}
s.update(s2)
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
s.update([12, 13, 14])
print(s) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
# 清空
s.clear()
print(s) # set()
# 集合关系测试，交集，差集，并集
s = {1, 2, 2, 2, 3, 4, 5, 6, 7, 7, 8, 9}
s3 = {10, 11, 12, 13, 1, 3, 5}
# 求交集
s.intersection(s3) # 方法一
print(s.intersection(s3)) # {1, 3, 5}
s4 = s & s3 # 方法二
print(s4) # {1, 3, 5}
# 求差集
s.difference(s3) # 方法一，求s和s3的差集，s有，s3中没有的
print(s.difference(s3)) # {2, 4, 6, 7, 8, 9}
s5 = s - s3 # 方法二，求s和s3的差集，s有，s3中没有的
print(s5) # {2, 4, 6, 7, 8, 9}
# 求并集
s.union(s3) # 方法一
print(s.union(s3)) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
s6 = s | s3 # 方法二
print(s6) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
# 取交集相反，即不交集的地方取出来
s.symmetric_difference(s3) # 方法一
print(s.symmetric_difference(s3)) # {2, 4, 6, 7, 8, 9, 10, 11, 12, 13}
s7 = s ^ s3 # 方法二
print(s7) # {2, 4, 6, 7, 8, 9, 10, 11, 12, 13}
# 包含关系
s8 = {1, 2, 3}
s.issuperset(s8) # 方法一，判断集合是不是包含其他集合，证明s8是s的子集
print(s.issuperset(s8)) # True
s9 = (s >= s8) # 方法二，利用>=来进行判断
print(s9) # True
s.issubset(s8) # 判断集合是不是被其他集合包含,也可等同于s<=s8
print(s.issubset(s8)) # False
# 判断是否相交
s.isdisjoint(s3) # 判断两个集合是不是不相交
print(s.isdisjoint(s3)) # False,此时表示两个集合相交
# 赋值差集的结果
s = {1, 2, 3, 5, 4, 6, 9, 8, 7}
s10 = {1, 2, 3, 10, 11}
s10.difference_update(s)
print(s10) # 将s10中，s10与s的差集赋值给s10
6，格式化输出：
name = input('Name:') age = int(input("Age:"))#要输出数字，int声明 sex = input('Sex:') hometown = input('Hometown:') info= """ #多行字符，使用"""-------------------info of %s------------------- Name: %s Age: %d Sex: %s Hometown: %s -------------------end----------------------- """%(name,name,age,sex,hometown) #s = string 字符占位符，%为连接符 #d = digit 数字占位符 #f = float 浮点数占位符 print(info)
s用的表较多
采用格式化输出，可以使得程序变得更加简洁美观
7，运算符
示例a=10, b=20
1，算术运算
2，比较运算
3、赋值运算：
4，逻辑运算
5，成员运算
8，流程控制
流程控制的作用：流程（程序的执行顺序：至上而下）+控制（是否执行/循环）
单分支：
if 条件：
满足条件后要执行的代码块
name = input("Name:") sex = input("Sex:") age = int(input("Age:")) if age < 28: if sex == 'female': print("我喜欢女生") else: print("姐弟恋也不错") else: print("都是男的，我们不来搞基")
多分支：
if 条件：
满足条件后要执行的代码块
elif 条件：
上面的条件不满足就走这个
elif 条件：
上面的条件不满足就走这个
age = 25 user_guess = int(input("你们来猜下我的年龄：")) if user_guess == age: print("恭喜猜对了！！") elif user_guess < age: print("Be bigger.") else: print("Be smaller")
grade = int(input("Please enter your grade:")) if 90 <= grade <= 100: print("You can get A.") elif 80 <= grade <= 90: print("You can get B.") elif 60 <= grade <= 79: print("You can get C.") elif 40 <= grade <= 59: print("You can get D.") elif 0 <= grade <= 39: print("You can get E.") else: print("成绩考不了负数的。") print("Thank you for searching")
while循环
while 条件：
执行代码...
num = 0 while num <= 100: if num == 50: print("此时50不打印") elif 60 <= num <= 80: print("num=",num**2) elif num % 2 == 0: print("double",num) num += 1 print("end")
while循环可以没有边界，但是for循环一定有边界。
Dead Loop(死循环)
count=0
while True:
print("millionnare",count)
count+=1
循环终止语句：
break语句或continue语句
break用于完全结束一个循环，跳出循环体执行循环后面的语句
continue和break有点类似，区别在于continue只是终止本次循环，接着还执行后面的循环，break则完全终止循环
例子:break count = 0 while count <= 100 : #只要count<=100就不断执行下面的代码 print("loop ", count) if count == 5: break count +=1 #每执行一次，就把count+1，要不然就变成死循环啦，因为count一直是0 print("-----out of while loop ------") 输出 loop 0 loop 1 loop 2 loop 3 loop 4 loop 5 -----out of while loop ------ 例子：continue count = 0 while count <= 100 : count += 1 if count > 5 and count < 95: #只要count在6-94之间，就不走下面的print语句，直接进入下一次loop continue print("loop ", count) print("-----out of while loop ------") 输出 loop 1 loop 2 loop 3 loop 4 loop 5 loop 95 loop 96 loop 97 loop 98 loop 99 loop 100 loop 101 -----out of while loop ------
# 要求： # # 允许用户最多尝试3次 # 每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y或y, 就继续让其猜3次，以此往复，如果回答N或n，就退出程序 # 如何猜对了，就直接退出 age = 25 count = 1 while count <= 3: user_guess = int(input("你们来猜下我的年龄：")) if user_guess == age: print("恭喜猜对了！！") break elif count < 3: if user_guess < age: print("Bigger.") else: print("Smaller.") count += 1 if count == 4: choice = input("你还想玩吗？(y|Y):") if choice == "y" or choice == "Y": count = 1
while...else用法
当while循环正常执行完，中间没有被break终止的话，就会执行else后面的语句。
count = 0 while count <= 5 : count += 1 print("Loop",count) else: print("循环正常执行完啦") print("-----out of while loop ------") 输出 Loop 1 Loop 2 Loop 3 Loop 4 Loop 5 Loop 6 循环正常执行完啦 -----out of while loop ------ 如果执行过程中被break啦，就不会执行else的语句啦 count = 0 while count <= 5 : count += 1 if count == 3:break print("Loop",count) else: print("循环正常执行完啦") print("-----out of while loop ------") 输出 Loop 1 Loop 2 -----out of while loop ------
9，进制与转换
取值范围：
二进制(binary)：0-1
八进制：0-7
十进制：0-9
十六进制：0-9，A-F
十进制(整型)转换2，8，16进制语法
bin() 二进制 # 括号中一定要填十进制整型
oct() 八进制 # 通过参数进行判断，也即oct函数可将任意进制的数转换为8进制
hex()十六进制 # 括号中只接受10进制
进制的转换: 各种进制之间的转换
转换为十进制的方法
int(string, base) # 第一个参数标识：需要转换的原始的数据，以字符串的形式表示 # 第二个参数标识：原始数据的base或者叫本身的进制表示 # 2：二进制 # 8：八进制 # 16：表示16进制 # 最终转化为十进制 # 二进制到十进制 int('1010', 2) 10 # 十六进制到十进制 int('f', 16) 15 # 等等等等，只需要把第一个srting位置输入原始的数据，在base位置输入本身进制数字表示，即可最终将他们转换成十进制。
一位十六进制要四位二进制表示
为什么用16进制
1、计算机硬件是0101二进制的， 16进制刚好是2的倍数， 更容易表达一 个命令或者数据。十六进制更简短， 因为换算的时候一 位16进制数可以顶4位2进制数，也就是一个字节(8位进制可以用两个16进制表示)
2、最早规定ASCII字符集采用的就是8bit(后期扩展了但是基础单位还是8bit), 8bit用2个16进制直接就能表达出来， 不管阅读还是存储都比其他进制要方便
3、计算机中CPU运算也是遵照ASCII字符集，以16、 32、64的这样的方式在发展，因此数据交换的时候16进制也显得更好
4、为了统一规范，CPU、内存、硬盘我们看到都是采用的16进制计算
16进制用在哪里
1、 网络编程，数据交换的时候需要对字节进行解析都是一个byte一个byte的处理，1个byte可以用OxFF两个16进制来表达。通过网络抓包，可以看到数据是通过16进制传输的。
2、数据存储，存储到硬件中是0101的方式，存储到系统中的表达方式都是byte方式
3、 一些常用值的定义，比如:我们经常用到的html中color表达， 就是用的16进制方式，4个16进制位可以表达好几百万的颜色信息。
char(num)将ASCII值得数字转换成ASCII字符，范围只能是0-255
ord(char)接受一个ASCII值字符，返回相应的ASCII值
容量
每一位0或1所占的空间单位为bit(比特)，这是计算机中最小的表示单位
8bits = 1Bytes字节,最小的存储单位，1bytes缩写为1B
1024Bytes = 1KB = 1KB
1024KB = 1MB
1024MB =1GB
1024GB = 1TB
1024TB = 1PB
10，字符编码
python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ASCII）
1，ASCII
（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。显然ASCII码无法将世界上的各种文字和符号全部表示，所以，就需要新出一种可以代表所有字符和符号的编码，即：Unicode 【最少由 16 位来表示（2个字节）】
2，Unicode
（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536，
注：此处说的的是最少2个字节，可能更多
3，UTF-8
是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ASCII码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存...
所以，python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ASCII），如果在python2.x中，默认只支持ASCII，所以出现中文会报错，此时应该告诉python2.x的解释器可以使用什么编码来解释
python2.x默认编码是ASCII；默认不支持中文，支持中文需要加：#_*_ coding:utf-8 _*_ 或者 #!encoding:utf-8
Python3.x默认编码是UTF-8，默认支持中文
无论以什么编码在内存里显示字符，存到硬盘上都是二进制。不同编码的二进制是不一样的
存到硬盘上以何种编码存的，那么读的时候还得以同样的编码读，否则就乱码了。
简单一点：
1，ASCII 8位表示一个字符 1字节(Byte) = 8字位 =8个二进制数，ASCII码一般第一位都为0
2，unicode（万国码）2个字节表示一个字符，改版后4个字节表示一个字符
3，UTF-8：unicode升级版：最少用一个字节标识一个字符，UTF-16：最少用两个字节表示一个字符
ASCII：用一个字节标识一个字符
欧洲文字：用两个字节表示一个字符
亚洲文字：用三个字节表示一个字符
4，gbk：国标，中国人自己使用，只包含英文与中文
一个英文一个字节
一个中文两个字节
4，高级货
python3
文件编码默认 ：utf-8
字符串编码：unicode
python2
文件编码默认：ascii
字符串编码默认：ascii
如果文件头声明了utf-8，那字符串的编码是utf-8
unicode是一个单独的类型
python3的内存里：全部是unicode
python3执行代码的过程：
1、解释器找到代码文件，把代码字符串按文件头定义的编码加载到内存，转成unicode
2、把代码字符串按照python语法规则进行解释
3、所有的变量字符都会以unicode编码声明
在python2里边，默认编码是ASCII编码，那么文件头声明是utf-8的代码，在windows中将显示乱码
如何在windows上显示正常呢？（windows的默认编码是gbk）
1、字符串以gbk格式显示
2、字符串以unicode编码
修改方法：
1.UTF-8 -- >decode解码 --> Unicode
2.Unicode -- > encode编码 -- > GBK / UTF-8
5，python中bytes类型
二进制的组合转换成16进制来表示就称之为bytes类型，即字节类型，它把8个二进制组成一个bytes，用16进制来表示。
在python2里，bytes类型和字符串是本质上时没有区分的。
str = bytes
因为要表示图片，视频 等二进制格式的数据，所以才有bytes。
python2 以utf-8编码的字符串，在windows（windows上面默认gbk）上不能显示，乱码。
如何在python2下实现一种，写一个软件，在全球各国电脑上 可以直接看？
以unicode编码写软件。
s = you_str.decode("utf-8")
s2 = u"阴间神探"
unicode类型 也算字符串
声明的文件头：
python2：以utf-8 or gbk 编码的代码，代码内容加载到内存，并不会被转成unicode，编码依然是utf-8 或 gbk。
python3：以utf-8 or gbk编码的代码，代码内容加到在内存，会被自动转成unicode。
utf-8 or gbk → 代码加载到内存中 → 自动转换成unicode → 使用unicode进行python3的语法解释
在python3里，bytes类型主要来存储图片、视频等二进制格式的数据
str = unicode
默认就支持了全球的语言编码
常见编码错误的原因有：
1、python解释器的默认编码是否符合
2、python源文件文件编码，写这个文件的时候是什么编码，在文件中声名就是什么编码。
3、终端(Terminal)使用的编码（windows/linux/os）
4、操作系统的语言设置