Python学习笔记整理Module1
-
编程语言介绍
- python介绍
- python安装
- 第一个python程序
- 变量
- 程序交互
- 格式化输出
- 数据运算
- 数据类型
- 控制流程
- 进制与字符编码
编程语言介绍
编程语言的定义及作用：
编程的定义：‘动词’即写代码。
编程的作用：让计算机以人类的思维执行某些事件。
编程语言的分类：
- 机器语言
- 汇编语言
- 高级语言
机器语言与汇编语言属于低级语言.
机器语言：由于计算机只能识别二进制码，因此用二进制码0和1描述的指令为机器指令。全部由机器指令集合构成的语言称之为机器语言。
- 优点：执行速度快
- 缺点：直观性差，学习困难
汇编语言：汇编语言的实质性是与机器语言相同的都是对计算机硬件进行操作。不同的是指令采用英文缩写的形式更方便记忆和识别。
高级语言：高级语言相比汇编语言，不但将许多相关的机器指令合成为单条指令，比并且去掉了许多与操作有关与完成工作无关的繁琐细节。例如堆栈，寄存器等。这样就大大的简化了程序中的机器指令，由于忽略了很多细节，so 学习起来更加方便，编程者也不需要太多的相关知识。
高级语言的分类：
- 编译型
- 解释型
编译型：在程序执行前。把源程序翻译成机器码。因此其目标程序可以脱离其语言环境独立运行。程序一旦修改，就必须修改源文件程序编译。
- 优点：运行速度快，可脱离环境单独运行
- 缺点：可移植性（跨平台）差，修改比较繁琐
解释型：目标程序由解释器翻译成机器语言才能执行，因此执行速度慢，且不可脱离环境单独运行，由于不需要提前翻译成机器语言，使用修改想比编译型的语言方便许多
- 优点：可移植性强，修改方便
- 缺点：运行速度慢，需要语言环境才能运行
python介绍
python介绍：
创始人：吉多 范罗苏姆（guido van rossum）
1989年圣诞节期间，guido开始写python语言编译器.他的初衷是创造一种c和shell之间简单易学，功能全面可扩展的语言
python的发展史：
1994年：python1.0
2000年：python2.0
2004年：python2.4同时django诞生
2006年：python2.5
2008年：python2.6
2008年：python3.0
2009年：python3.1
2010年：python2.7（过渡版本支持到2020年）同时支持2.x和3.x的特性
2011年：python3.2
2012年：python3.3
2014年：python3.4
2015年：python3.5
python解释器：
- cpython:
这个解释器是c语言开发的，所以叫cpython.在命令行下运行python就是启动cpython解释器
- ipython:
ipython是基于cpython之上的一个交互式解释器，也是就说，ipython只是在交互上有所增强，但只是代码是和cpytho完全一样的。
- pypy:
pypy是另一个python解释器，它的目标是执行速度。pypy采用jit技术，对python代码进行动态编译，所以可以显著提高python代码执行速度.
- jython:
jython是运行在java平台上的python解释器，可以直接把python代码编译成java字节码执行.
- ironpython:
ironpython和jython类似，只不过ironpython是运行在微软.net平台上的python解释器，可以直接把python代码编译成.net字节码
python安装：
下载地址：https://www.python.org/downloads/windows/
windows：
默认下一步
验证是否安装成功：win+r 输入cmd 出现以下字符即表明安装成功
c:\users\67525>python python 3.6.6 (v3.6.6:4cf1f54eb7, jun 27 2018, 03:37:03) [msc v.1900 64 bit (amd64)] on win32 type "help", "copyright", "credits" or "license" for more information. >>>
错误提示：不是内部命令
解决办法：配置path环境
计算机（此电脑）鼠表右键 --> 属性 --> 高级系统设置 -->高级 （环境变量） --> 在path中添加 python的安装路径
linux or mac：
一般自带python2.7 or python2.6，需要可其他版本自行安装。
安装其他版本已python3.6为例：
需要先下载python3.6.的源码包
# tar -zxvf python-3.6.1.tgz # cd python-3.6.1 # ./configure # make && make instal
检查是否安装成功：
# python3 -v python 3.6.1
第一个pthon程序
1.新建文件hello.py 编辑以下内容：o
1 print('hello world!')
在cmd下输入 python hello.py
2.在python交互器下
d:\>python
python 3.6.6 (v3.6.6:4cf1f54eb7, jun 27 2018, 03:37:03) [msc v.1900 64 bit (amd64)] on win32
type "help", "copyright", "credits" or "license" for more information.
>>> print('hello world')
hello world
>>>
变量：
变量的作用：就是把程序运算的中间结果存放到内存里，以便后面的代码继续调用
变量名的定义规则：
- 变量名是字母下划线及数字的任意组和
- 变量名的首位字符不可为数字
- 以下关键字不可以用作变量名
定义变量名要避免的几种方式：
- 变量名为中文或拼音
- 变量名过长
- 变量名词不达意
变量的赋值
1 number = 5 2 name = 'xuange'
变量的命名习惯
#驼峰体 ageofoldboy = 56 numberofstudents = 80 #下划线 age_of_oldboy = 56 number_of_studnets = 80
常量
常量：即不可变得量，在python中并没有特定的语法来声明常量，只需把常量名全部使用大写即可.
常量的定义：
pi = 3.1415826 print(pi)
用户交互及注释
作用：接收用户输入的值，默认类型为字符串
语法：
#语法
name = input('name:')
特定条件下需要接收密码可用模块中的getpass模块
import getpass
passwd = getpass.getpass('passwd:')
注释
#这是单行注释 ''' 这是多行注释 '''
注释原则：只需要在不容易理解的地方加入注释即可，不需要全部都加注释。可以使用中文或者英文，禁止使用拼音
格式化输出
作用：按照指定格式打印内容。
占位符：
- %s 字符串类型
- %d 数字类型
- %f 浮点数类型
常见的三种字符串格式方式：
1 ##常见的几种方法
2 name = input('name:')
3 age = input('age:')
4 job = input('jbo:')
5 salary = input('salary:')
6 #方法一
7 info = '''
8 -------info %s -------
9 name: %s
10 age: %s
11 job: %s
12 salary: %s
13 ------ the end ---------
14 ''' % (name, name, age, job, salary)
15 print(info)
16 # 方法二
17 info = '''
18 ----- info {_name}
19 name: {_name}
20 age: {_age}
21 job: {_job}
22 salay: {_salary}
23 '''.format(_name=name, _age=age, _job=job, _salary=salary)
24 print(info)
25 #方法三
26 info = '''
27 ------info {0} ----
28 name :{0}
29 age:{1}
30 job:{2}
31 salary: {3}
32 ''' .format(name, age, job, salary)
33 print(info)
34 #一种缩写
35 b = 'bbb'
36 print(f'aaaa{b}')
数据运算
- 算数运算符
- 比较运算符
- 赋值运算符
- 逻辑运算符
- 成员运算
- 身份运算
- 位运算
算数运算符
1 #例子： 2 >>> a = 10 3 >>> b = 5 4 >>> c = a+b 5 >>> c 6 15 7 >>> c = a-b 8 >>> c 9 5 10 >>> c = a*b 11 >>> c 12 50 13 >>> c = a/b 14 >>> c 15 2.0 16 >>> c = a % b 17 >>> c 18 0 19 >>> c = a ** b 20 >>> c 21 100000 22 >>> c = a //b 23 >>> c 24 2
比较运算：
#例子： >>> a = 5 >>> b = 3 >>> a == b false >>> a !=b true >>> a > b true >>> a < b false >>> a >= b true >>> a <= b false >>>
赋值运算
#
例子：
>>> a = 5
>>> b = 3
>>> b += a #b = b+a
>>> b
8
>>> b -= a #b= b-a
>>> b
3
>>> b *= a #b = b*a
>>> b
15
>>> b /= a #b = b/a
>>> b
3.0
>>> b %= a #b = b%a
>>> b
3.0
>>> b **= a #b = b**a
>>> b
243.0
>>> b //= a #b = b//a
>>> b
48.0
>>>
逻辑运算
例子 >>> a = 15 >>> b = 20 >>> a == 15 and b ==20 #所有条件都满足才会为true true >>> a < 20 and b >20 false >>> a < 20 or b > 20 # 一个条件成立就为true true >>> not a< 20 #取反 false
成员运算
#例子： >>> list = [1,2,3,5,6,7] >>> 1 in list true >>> 4 in list false >>> 1 not in list false >>> 4 not in list true >>>
身份运算
#例子： #如果id(a)等于id(b) 则返回true ,反之返回 false >>> a = 5 >>> b = a >>> a is b true # 如果 id(a)不等于id(b)则返回true, 反之返回false >>> a = 7 >>> a is not b true >>>
位运算：
暂时没搞明白，先不写~~~
数据类型
- 基础数据类型
- 数据集
基础数据类型
数字
- 整数
- 浮点数
- 复数
整数
整型： 在32位机器上取值范围为 -2* *31 ~ 2 * *31-1 ，64位机器上取值范围为：-2 ** 63 ~ 2 * *63-1
长整型：在python3中没有整型和长整型之分
浮点数
浮点数：浮点数是属于有理数中特定子集的数字表示，在计算机中用以表示任意某个实数。
科学计算法：
就是把一个数字以a*10n次幂的方式表现出来。计算机一般把10的几次幂用中的10以e或者e来表示.且a>=1,a<10
浮点数的精度问题：
由于在计算机内部整数和浮点数的内存存储方式不同，整数运算永远是精确的，而浮点数运算则会有四舍五入的误差。
python默认的是17位精度，也就是小数点后16位，但这个精度越往后越不准.
计算高精度的浮点数方法：
from decimal import * getcontext() getcontext().prec = 20 a = decimal(1)/decimal(3) print(a)
也可以使用字符串格式化的方式来表示：
>>> a =('%.30f'%(1.0/3))
>>> a
'0.333333333333333314829616256247'
>>>
复数
复数是指能写成如下形式的数a+bi，a和b为实数i是虚数。在复数a+bi中,a为复数的实部，b为复数的虚部，i为虚数的单位，当虚部等于0时，这个复数就是实数，当虚部不等0时，这个数就是虚数
#例子 >>> a = (-5+4j) >>> a (-5+4j) >>> type(a) <class 'complex'> >>>
其中-5,4为实数，j为虚数.
字符串
字符串特性及定义：有序不可修改的字符集合，由一对单，双，三引号包含 包含的内容即字符串
字符串作用：用于存储文本信息
字符串的操作方法：
1 s = 'hello world'
2
3 s.capitalize() #返回首字母为大写的字符串
4 s.casefold()
5 s.center() #以该字符串为中心填充该字符串 参数：长度 ，以什么字符填充（默认空格）
6 s.count() #查看该字符串某个字符出现的次数 参数：查看的字符，起始，结束（默认为空）
7 s.encode() #以指定编码格式编码字符串 参数：编码（默认utf-8）,设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个unicodeerror. 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
8 s.endswith() #检查字符串是否以 obj 结束. 参数：该参数可以是一个元素或是字符串,起始位置，结束位置
9 s.expandtabs() #扩展tab建 参数：tab键长度（默认：8个空格）
10 s.find() #坚持字符串中是否包含子字符串str 参数：检索的字符串,起始位置,结束位置
11 s.format() #字符串格式化 参数：
12 s.index() #检测字符串是否包含子字符串str 参数：检索的字符串。起始位置，结束位置
13 s.isalnum() #如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 true,否则返回 false
14 s.isalpha() #如果字符串至少有一个字符并且所有字符都是字母则返回 true, 否则返回 false
15 s.isdecimal() #如果字符串中只有十进制字符，返回true，否则返回false
16 s.isdigit() #如果字符串只包含数字则返回 true 否则返回 false
17 s.isidentifier() #如果字符串是有效的表示符则返回 true 否则返回false
18 s.islower() #如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 true，否则返回 false
19 s.isnumeric() #如果字符串中只包含数字字符，则返回 true，否则返回 false
20 s.isprintable() #如果该字符串可以打印返回true 否则返回false
21 s.isspace() #如果如果字符串中只包含空格，则返回 true，否则返回 false.
22 s.istitle() #如果字符串是标题化的则返回 true，否则返回 false
23 s.isupper() #如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 true，否则返回 false
24 s.join() #以指定字符串分割符分割串 参数：要连接的元素序列
25 s.ljust() #回一个原字符串左对齐,填充至指定长度 参数：长度,以什么填充（默认空格）
26 s.lower() #将字符串中所有的大写转为小写
27 s.lstrip() #截掉字符串左边的空格或指定字符。 参数：指定截取的字符（默认空格）
28 s.maketrans() #创建字符映射转换表 参数：intab:要代替的字符组成的子字符串 outtab:要代替的字符组成的字符串
29 s.partition() #在字符串中以seq为分隔符，分割字符串 参数：seq 分割方法
30 s.replace() #将，某个字符替换为另一个字符 参数：旧的字符，新的字符，替换次数（默认全部替换）
31 s.rfind() #类似find(),区别就是从右边开始查找 参数：查找的字符串，起始位置，结束位置
32 s.rindex() #类似index(),区别就是从右边开始查找 参数：查找的字符串，起始位置，结束位置
33 s.rjust() #与ljust()方法相似，区别就是右对齐，填充字符串。 参数：长度，以什么填充（默认空格）
34 s.rpartition() #在字符串中以seq为分隔符，中字符串右边开始分割字符串 参数：seq 分割符
35 s.rsplit() #以str为分割符截取字符串，从右边开始截取 参数：分隔符，分割次数
36 s.rstrip() # 截掉字符串右边的空格或指定字符。 参数：指定截取的字符（默认空格）
37 s.split() # 以 str 为分隔符截取字符串 参数：分割符 分割次数
38 s.splitlines() #以按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表 参数：keepends 默认为false 为true则保留换行符
39 s.startwith() #检测字符串是否已str开头 参数：检索的字符串，可选参数-设置起始位置，可选参数设置结束位置
40 s.strip() #去除字符串两边的空格 参数：移除指定的序列
41 s.swapcase() #字符串中的字符大小写互换
42 s.title() #将字符串转换成标题格式
43 s.translate() #以指定表转换字符串的字符（一般与maketrans配合使用） 参数：翻译表，要过滤的字符
44 s.upper() #将字符串中的小写转换为大写
45 s.zfill() #返回长度为width的字符串，原字符串右对齐，前面以0填充 参数：长度
46 ###补充
47 len(s) #返回字符串的长度
布尔
作用：用来进行逻辑判断
分为真或假（true false）
>>> a =3 >>> b = 5 >>> a > b false >>> a < b true
数据集
- 列表
- 字典
- 元组
- 集合
列表
列表的定义：有序的
列表的特性：有序可修改的数据集合
列表的创建
l1 = [1, 2, 3] # 创建空列表 l2 = [] l3 = list()
列表的操作
c:\users\67525>python
python 3.6.6 (v3.6.6:4cf1f54eb7, jun 27 2018, 03:37:03) [msc v.1900 64 bit (amd64)] on win32
type "help", "copyright", "credits" or "license" for more information.
>>> l = [1,2,3,4,5,6,7,8]
>>> # 访问列表中的值
...
>>> l[1]
2
>>> # 取索引
...
>>> l.index(5)
4
>>> # 切片
...
>>> l[1:5]
[2, 3, 4, 5]
>>> # 添加
...
>>> l.append(8)
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 8]
>>> l.insert(5,'5')
>>> l
[1, 2, 3, 4, 5, '5', 6, 7, 8, 8]
>>> #修改
...
>>> l[0] = 0
>>> l
[0, 2, 3, 4, 5, '5', 6, 7, 8, 8]
>>> #删除
>>> l.pop()
8
>>> l
[0, 2, 3, 4, 5, '5', 6, 7, 8]
>>> l.remove('5')
>>> l
[0, 2, 3, 4, 5, 6, 7, 8]
>>> l.pop()
8
>>> l
[0, 2, 3, 4, 5, '5', 6, 7, 8]
>>> l.remove('5')
>>> l
[0, 2, 3, 4, 5, 6, 7, 8]
>>> # 循环
>>> for i in l:
... print(i)
...
0
2
3
4
5
8
>>> # 排序
...
>>> l = ['a','c','b','e','f','d','m','n','@']
>>> l
['a', 'c', 'b', 'e', 'f', 'd', 'm', 'n', '@']
>>> l.sort()
>>> l
['@', 'b', 'f', 'n', 'a', 'c', 'd', 'e', 'm']
>>> # 倒序
...
>>> l.reverse()
>>> l
['m', 'e', 'd', 'c', 'a', 'n', 'f', 'b', '@']
>>>
列表的方法详解：
l = [1,23,3,4,5,6,7]
l2 =['a','b']
l.append('追加') #追加一个值 参数：要追加的值
l.copy() #浅copy
l.count(23) #查看某个值在该列表中出现的次数 参数： 要查看的值
l.extend(l2) #拼接列表 参数：要拼接的列表
l.index(3) #取列表中某个值得索引 参数：要取索引的值，起始位置，结束位置
l.insert(5,'插入') #插入一个值 参数：要插入的位置，要插入的值
l.pop() #取列表最后一个值，并删除 参数：可选项，某个值得索引
l.remove() #删除指定的值 参数：要删除的值
l.reverswe() #倒序
l.sort() #排序 #参数 排序方法(默认ascii码)可选参数 ，是否倒序默认为false
l.clear() #清空
深浅copy
l1 = [1,2,3,4,5] l2 = l1
该方法 l2则是完全指向了l1的内存地址，所以修改任意列表，其他列表也会跟着受影响。
浅copy：copy一份独立的列表（如果有子列表子列表不独立）。
列表的内存地址是独立的，列表中的值的内存也是独立的. 浅copy，则会给新的列表开辟新的内存地址，列表中的值则会使用原列表的内存地址，如果修改则会像字符串一样在对修改的值开辟一块新的内存地址，因此两个列表之间互相影响。 如果copy的列表中包含子列表（嵌套列表），由于子列表是两个列表共享的，因此子列表并不是有单独的内存地址，，所以修改子列表中的值，两个列表都会受影响。
深copy：copy一份完全独立的列表(包括子列表)
import copy l1 = [1,2,3,[4,5]] l2 = copy.deepcopy(l1)
字典
字典的特性：key-value结构、key必须可hash且必须为不可变数据类型而且唯一、可存放多个值
可修改、无序、查找速度快
#创建字典
>>> dict={1:2,3:4,5:6,7:9,8:5}
>>> dict
{1: 2, 3: 4, 5: 6, 7: 9, 8: 5}
#添加>>>
>>> dict['test']=1
>>> dict
{1: 2, 3: 4, 5: 6, 7: 9, 8: 5, 'test': 1}
#修改
>>> dict['test'] = 3
>>> dict
{1: 2, 3 4, 5: 6, 7: 9, 8: 5, 'test': 3}
#查找
>>> dict.get('test')
3
>>> dict['test'] #次方法如果一个key不存在就会报错，而get方法则返回none
3
#循环
>>> for key in dict:
... print(key,dict[key])
...
1 2
3 4
5 6
7 9
8 5
test 3
字典的方法详解：
dict.clear() #清空字典 dict.copy() #浅copy dict.fromkeys() #创建一个新的字典，以指定的元素做字典的key，val为字典所有建对应的初始值 参数：字典键值列表，可选参数 键值序列的初始值 dict.get() #返回指定key的值，如果值不在字典中返回default值 参数：字典的键值 key不存在时返回的值 dict.keys() #返回列表的所有key dict.pop() #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 参数：要删除的键值，返回值 dict.popitem() #随机返回并删除字典中的一对键和值(一般删除末尾对)。如果字典已经为空，却调用了此方法，就报出keyerror异常 dict.setdefault() #与get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值 参数：查找的键值，返回的值 dict.update() #把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。 参数：要添加的字典（dict2） dict.values() #返回列表里所有的value
元组
元组的定义：与列表类似，由于不可变的特性被称为只读列表
元组的特性：有序不可变，如果元组中包含其他可变元素，这些可变元素可以改变
元组的操作：
name=('alex','test','shadan')
其他操作
t = (1,2,3,4,2,5,6) print(t.index(2,3,5)) print(t.count(2)) # t.index方法:取索引值 参数：要取索引的元组参数 , 从哪里开始 , 到哪里结束 # t.count方法：查看某个参数在该元组中的个数 参数:取值对象 #切片 t1 = t[2::2] print(t1)
集合
集合的作用：去重，测试两组数据之间的交集、差集、并集等关系。
集合的特点：无序且不重复的数据集合确定性（元素必须可hash）
集合的操作：
1 #集合的创建
2 >>> set = {1,2,3,4,5}
3 >>> set2 ={2,3,5,7,8}
4 #添加
5 >>> set.add(9)
6 >>> set
7 {1, 2, 3, 4, 5, 9}
8 >>> set.update([8,5,0])
9 >>> set
10 {0, 1, 2, 3, 4, 5, 8, 9}
11 #删除
12 >>> set.discard(8)
13 >>> set
14 {0, 1, 2, 3, 4, 5, 9}
15 >>> set.pop()
16 0
17 >>> set
18 {1, 2, 3, 4, 5, 9}
19 >>> set = {1,4,7,2,5,8,}
20 >>> set
21 {1, 2, 4, 5, 7, 8}
22 >>> set.remove(4)
23 >>> set
集合的关系测试:
#取交集
>>> set.intersection(set2)
{2, 3, 5}
>>> set&set2
{2, 3, 5}
#取差集
>>> set.difference(set2)
{1, 4, 9}
>>> set-set2
{1, 4, 9}
#取并集
>>> set.union(set2)
{1, 2, 3, 4, 5, 7, 8, 9}
>>> set | set2
{1, 2, 3, 4, 5, 7, 8, 9}
#取对称差集
>>> set.symmetric_difference(set2)
{1, 4, 7, 8, 9}
>>> set^set2
{1, 4, 7, 8, 9}
集合的方法详解：
set = {1,2,3,4,5}
set.add() #添加一个值到该集合 参数：添加的元素
set.clear() #清空该集合
set.copy() #拷贝一个集合
set.difference() #取差集 参数：要取差集的集合
set.difference_update() #方法用于移除两个集合中都存在的元素。 参数：用于计算差集的集合
set.discard() #删除指定的集合元素，如果该元素更不存不会报错 参数：要删除的元素
set.intersection() #取交集 参数：要取交集的集合，其他要取交集的集合（可选参数）多个用逗号隔开
set.intersection_update() #方法用于移除两个或更多集合中都不重叠的元素。 参数：要查找相同元素的集合，其他要查找相同元素的集合（可选项多个用逗号分隔）
set.isdisjoint() #判断两个集合是否包含相同元素 参数：要比较的集合
set.issubset() #判断另一个集合是是否包含次集合 参数
set.issuperset() #判断集合的所有元素是否都包含在指定集合中。 参数：要查找的集合
set.pop() #随机删除一个元素
set.remove() #删除一个指定的元素，如果该元素不存在则报错 参数：要删除的元素
set.symmetric_diffetrence() #返回两个集合中不重复的元素集合 参数：要计算的集合
set.symmetric_diffetrence_update() #移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中 #参数：要判断的集合
set.union() #取并集 参数：要取并集的集合,可选多个集合用逗号分隔
set.update() #给集合添加元素 参数：添加的元素，可以是集合
控制流程
分支：判断在特定的条件下执行特定的事件
- 单分支
- 双分支
- 多分支
- 空语句（pass）
单分支
#语法：
if 条件：
要执行的事件
双分支：
#语法：
if 条件：
要执行的事件
else：
要执行的事件
多分支：
if 条件： 要执行的事件 elif 条件：
要执行的事件 elif 条件：
要执行的事件 ... else:
要执行的事件
空语句：
pass
作用：为了保持程序的完整性，pass不做任何事情，一般用作占位语句.
#语法
if 条件： pass else: 要执行的事件
循环:重复执行某些特定事件
- while循环
- 死循环
- while else
- for循环
while循环：
# 语法
while 条件：
要执行的事物
死循环dead loop:
# 语法
while 条件用于为真： 要执行的事物
while else：
作用：判断循环是否被终止，在while条件为false的情况下执行else语句
while 条件：
要执行的事物
else：
要执行的事物
for循环
for i in range(10):
print(i)
i 为临时变量 range 可替换为列表或字典等..
for循环与while循环的区别：while循环可以是死循环而for循环不可以
循环终止语句
- break
- continue
break：完全终止循环，跳出循环体，执行循环体后面的语句
while 条件：
if 条件：
break
else：
要执行的事物
continue：终止本次循环，执行后面的语句
while 条件：
if 条件：
continue
else：
要执行的事物
进制与字符编码
进制
- 二进制
- 八进制
- 十进制
- 十六进制
二进制：
二进制的定义：由于计算机只能识别0和1，所以0和1组成的二进制码就是二进制数，最大可表现的10进制数为
2**位数-1
二进制的表现方式：01
二进制与十进制之间的运算：
填位法:
把165转换为二机制
128 64 32 16 8 4 2 1 1 0 1 0 0 1 1 0
python自带的方法
#参数：要转换的数字 #例子 >>> bin(155) '0b10011011' >>>
八进制
表现方式：12345678
八进制与十进制之间的运算
>>> oct(55) '0o67' >>>
十六进制
表现方式：0123456789abcdef
十六进制与二进制之间的运算
取四合一法：
python自带的方法
#python自带的转换方法 >>> hex(99) '0x63' >>>
字符编码
二进制与文字之间的关系：由于计算机只能识别二进制码，因此要识别文字需要特定的方法吧文字转换为二进制
ascii：（american standard code for information lnterchange）美国标准信息转换码
ascll码的作用：把文字转换为十进制数
文字与二级制之间的转换：
通过ascll码 把 *xuange*转换为二进制 #十进制 42 88 117 91 110 103 101 42 #二进制 * 00101010 x 01011000 u 01110101 a 01011011 n 01101110 g 01100111 e 01100101 * 00101010
计算机如何区分字符间的二级制码？
由于ascll码中最大的二级制数是255，而255转换为二级制最多占8位，所以表示每一个字符ascii码表对应关系的二进制数表示，不够则以为0填充。
计算机种的存储单位：
在二进制中每一个0或1所占的空间都为1bit，8bit等于1个字节（bytes），字节是计算机中最小的容量单位.
容量单位间的转换：
8bit = 1b(bytes) bytes:字节
1024kb = 1mb
1024mb = 1gb
1024gb = 1tb
1024tb = 1pb
字符编码的发展：
由于ascii码不支持中文，所以要想使计算机识别中文就得另行僻径。
gb2312:又称国标码，由国家标准局发布。1981年5月1日实施，共收录汉字6736个。
gbk1.0:1995年发布gbk1.0，gbk编码能够同时表示简体和繁体字，该编码标准兼容gb2312，共收录汉字21003个，同时包含中日韩文中所有的汉字。
gb18030:2000年发布，是对gbk编码的扩充，覆盖中文，日文，朝鲜语和中国少数名族文字，其*收录27484个汉字。同时兼容gbk和gb2312编码
big5编码：1984年发布，*地区使用
为了解决各个国家编码不互通的问题，iso标准组织拟订了unicode编码。
unicode编码：国际标准字符集，它将世界各种语言的没个字符定义唯一编码，以满足跨语言、跨平台的文本信息转换。unicode(统一码，万国码）规定每个字符和符号最少由16位来表示（2个字节），即：2**16 =65536
utf-8，是对uincode编码的压缩和优化，它不使用最少2个字节，而是将所有的字符和符号分类：ascii码中的内容用1个字节保存，欧洲的字符用2个字节保存。东亚的字符用3个字符保存
在python中使用字符编码
因为默认不支持中文，所以在python2中想要使用中文需要指定字符便码.
报错：
lucifer@lucifer-virtualbox:~$ python hello.py file "hello.py", line 2 syntaxerror: non-ascii character '\xe4' in file hello.py on line 2, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details
解决：在头文件指定字符编码
#! -*- coding:utf-8 -*- #coding=utf-8
结果：
#指定字符编码后 lucifer@lucifer-virtualbox:~$ python hello.py 你好 世界!
在python3中默认的字符编码为utf-8,所以不需要考虑编码的问题。
windows中文版默认编码：gbk
mac os/ linux 默认编码：utf-8
编码的一些补充
utf是unincode编码设计的一种在存储和传输时节省空间的编码方案.
字符编码的存储问题：以某种编码存储，必须以存储的编码方式打开
在代码执行的过程中，python3会自动的把代码内容变成unicode类型。而python2不会自动转换，所以需要把内容重新解码才可以正常显示。
由于windows中的默认编码是gbk，而python2解释器的默认编码为ascii，由于python2并不会把文件内容变成unicode。所以我们要手动的把内容变成unicode。
utf-8 --> decode 解码 --> unicode unicode --> encode 编码 --> gbk / utf-8 ..