python基础

　　　　　　　　　Python基础

1.什么是python？

　　python是一种面向对象的，解释型的计算机语言，它的特点是语法简介，优雅，简单易学。1989年诞生，Guido（龟叔）开发。

　　编译型语言：代码在编译之后，编译成2进制的文件，然后计算机就可用运行了。（C，C++，C#）

　　解释型语言：它是在运行的时候才编译的。（python，php，shell，ruby，js，java）

　　脚本语言：指这个语言只有一个单一的功能。（shell，js）

　　编译型程序运行效率高，速度快，不依赖语言运行环境，跨平台性差。

　　解释型开发效率高，运行效率低，跨平台性好，依赖解释器运行。

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的安装：打开官网下载中心

　　　　安装python时，下一步下一步安装完成后，需配置环境变量：我的电脑——属性——高级——环境变量——系统变量下的path双击——将安装python的路径输入——完成。在cmd命令下输入python，成功显示版本后，安装完成

3，变量(Variables)

　变量

　　变量：先定义后使用
　　变量作用：程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态以及状态的变化。

　　声明变量：变量名=变量的值

　　变量的命名规则：
　　　　1.变量名只能是数字、字母或下划线的任意组合
　　　　2.变量名的第一个字符不能是数字
　　　　3.以下关键字不能声明['and','as','assert','break','class','continue','def','elif','else','except','exec','finally','for','from','global','if','import','in','is','lambda','not','or','pass','print','raise','return','try','while','with','yield']

　　变量在python里面是按引用传递，底层是C(指针即地址(内存条的位置))

　　　　4.  定义方式：　　

　　　　#驼峰体
　　　　AgeOfOldboy = 56 
　　　　NumberOfStudents = 80
　　　　#下划线(推荐使用)
　　　　age_of_oldboy = 56 
　　　　number_of_students = 80

　　一夫(数据)多妻（变量），也即一个变量只能相对应一个数据，但是一个数据可以被多个变量所指向。

　　字面量(不同语言的字面量的类型不同)：在Python中，对字面常量（数字、字符串、布尔、字节）对象进行缓存，

多个变量赋相同值，其实是同一个值。

　　变量与内存：用编程思维进行理解，了解变量与内存的关系可以减少编码的bug，减少地址和内存的错误。

　常量

　　常量：程序在执行过程中不能改变的量
　　在Python中没有一个专门的语法代表常量，程序员约定俗成的变量名全部大写代表常量。

4，用户交互和注释

 　　在python3中

　　input：用户输入任何值，都存成字符串类型

name = input(" what's your name:") 
username= input("username:")
password= input("password:")

5，基本数据类型

判断字符串是何种类型

　　type(字符串)   # 这里的字符串只能判断一种类型，不能一起判断多种字符串类型。

　　<class '这里显示该字符串类型'>

数字：

#int整型
定义：age=18 #age=int(18)
用于标识：年龄，等级，身份证号，qq号，个数

#float浮点型
定义：salary=3.1 #salary=float(3.1)
用于标识：工资，身高，体重，

#int（整型）
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
#long（长整型）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
注意：在Python3里不再有long类型了，全都是int
>>> a= 2**64
>>> type(a)  #type()是查看数据类型的方法
<type 'long'>
>>> b = 2**60
>>> type(b)
<type 'int'>

#complex复数型
>>> x=1-2j
>>> x.imag
-2.0
>>> x.real
1.0

字符串：

　　

　　字符串：在Python中，加了引号的字符都被认为是字符串！
　　单双引号是没有任何区别的，如果遇到字符串中有单引号，此时要用双引号表明字符串；多行字符串必须用多引号。如果字母不加引号，会被认为是变量(此时变量还未赋值)，报错。

　　字符串拼接：字符串能进行“相加”和“相减”运算。但是注意，字符串的拼接只能是双方都是字符串，不能跟数字或者其他类型拼接单双引号。

布尔：

　　True、False ，主要用来做逻辑判断。True才进入，当0，False和None的时候为False，其他都是真

a=3
b=5
a > b #不成立就是False,即假
a < b #成立就是True, 即真


if a > b 
   print(a is bigger than b )

else 
   print(a is smaller than b )

列表：

　　列表是一个数据的集合，[ ] 内以逗号分隔，按照索引，可以存放n个任意类型的值，每个位置代表一个元素，可对集合进行方便的增删改查操作。

创建一个列表

l = []
#or
L = ['Adam', 95.5,'Lisa', 85, 'Bart', 59]
#or
list_test = list'xiong'
#or
list_abc = list('xiong','hui','fei')

常用操作：

　　　　　　索引，查找，切片，统计，追加，插入，修改，删除，显示长度，是否包含，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
['g', 'f', 'e', 'd', 'c', 'b', 'a']
  
#合并两个列表
>>>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 = n.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']

#分割
>>> s = 'hello world'
>>> s.split(' ')
['hello', 'world']
>>> s2= 'hello,world'
>>> s2.split(',')

#连接
>>> l = ['hi','eva']
>>> '!'.join(l)
'hi!eva'

元组：

·　　元组存在的价值、意义：保证数据安全

　　对于列表来说，两者差不多，也是存一组数，但是一旦创建，便不能修改，主要是用来读，所以又叫做只读列表。

　　元组的格式：元组名 = （元素1，元素2，...）

　　不可变，元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以修改。

　功能：

　　index，count，切片，遍历

　　

my_tuple = (1, 3, 5)
# 判断元素在元组中
if 3 in my_tuple:
    print("3存在")
# 判断元素不在元组中
if 33 not in my_tuple:
    print("33不存在")
# 查询元素的索引
index = my_tuple.index(1)
print(index) 
# 查询元素的数量
count = my_tuple.count(3)
print(count)

字典

　　作用：存多个值,key-value存取，取值速度快

　　　　key 必须可hash，必须为不可变数据类型，必须唯一
　　　　vlaue 可存放任意多个值，可修改，可以不唯一

　　　　字典是无序的

　　　　字典的查找速度快是因为字典可以把每个key通过hash变成一个数字（数字是按照ASCII码表进行排序的）

　　字典是python中唯一具有映射关系的数据类型：查询效率远高列表。映射表是占空间的。一一对应，哈希算法

1 #创建
  2 d={
  3     'xiong'：[22,'运维'，‘网络’]
  4      'wen'：[22，'管理'，'导游']
  5 }
  6 
  7 更改
  8 
  9     d['熊'][1] = 23
 10     print
 11     [23,'运维'，‘网络’]
 12 
 13 
 14 #键唯一且为不可表数据类型
 15 #d = {[1,2,3]:"xiong","name":"hao"}键不能是列表，列表是可变数据类型
 16     #对字典进行增加
 17         d = {"name":"xiong","name2":"hao"}
 18         d["age"] = 123 #增加键，重复的直接覆盖
 19         print(d)
 20     
 21     #对字典进行修改
 22         d["age"] = 21   直接锁定他的key进行变更
 23         d.["name2"] += ",xiong"
 24             name2 = haoxiong 
 25     #判断值是否在字典中
 26         "age" in d    
 27             Ture
 28     #获取    
 29         d.get("age")
 30             21
 31     #删除
 32      d.pop("name2")    
 33      del d ["name2"]    需指定，否则随机删除
 34      d.clear() #清空，字典还在
 35     
 36     其他操作
 37     d.items()   将key和value变成小元祖 
 38     d.update()  将两个字典合并，并将重复的值覆盖  
 39     d.setdefault('test','new')  在字典中get这个键和值，如果没有就创建
 40     d.fromkeys(['A','B','C'],'alex') 批量增加key和值
 41     print(d.keys)   打印所有的key
 42     print(d.values)  打印所有的value
 43     
 44     #对字典进行遍历
 45     d = {"name":"xiong","name":"hao"}
 46     for k in d:
 47     print(i,"------->",d[k])#利用print的特性
 48     print("%s ------->%s"%(k,d[k]))#推荐！！格式化输出
 49 
 50 
 51 
 52 
 53 
 54 #调用
 55 # print(d["name"])
 56 # v=d.get("name")#推荐  v=d.get("name",None)
 57 # print(v)
 58 
 59 # if not v:
 60 #     pass
 61 
 62 
 63 #遍历
 64 # for i in "hello":#in 后面加seq==序列 可以是字符串，列表，元祖，字典
 65 #     print(i)
 66 # for 循环次数由序列的一级元素的个数来决定
 67 # # i 是
 68 # print(range(10))
 69 #
 70 # for i in range(10):
 71 #     print()
 72 # for item in ["hello",123,[2,3,4]]:
 73 #     if item == 123:
 74 #         #continue    #结束本次循环
 75 #         break      #结束整个循环
 76 #     print(item)
 77 
 78 
 79 # while 条件表达式：
 80 #     执行代码
 81 # while 2>1:
 82 #     print("ok")
 83 #打印1-100
 84 # i =1
 85 # while i < 101:
 86 #     print(i)
 87 #     i+=1
 88 #
 89 # for i in range(1,101):#range 迭代器
 90 #     print(i)
 91 #
 92 
 93 
 94 
 95 #拿到索引和值
 96 # count = 0
 97 # for i in [11,22,33]:#
 98 #     print("%s------%s"%(count,i))
 99 #     count+=1
100 # #或者
101 # l = [1,2,33,4]
102 # for i in l:
103 #     print(l.index(i),i)
104 
105 # l = [1,2,33,4]
106 # for i,v in enumerate(l,1):#从1 开始走
107 #     print(i,v)
108 
109 
110 
111 # d2={"heidht":123,"sex":"male"} #
112 # d.update(d2)#将一个字典增加到另一个字典
113 # print(d)

# 可以这样创建一个字典

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}

　　

集合

　　　集合是一个无序的、不重复的数据组合
　　　作用：

　　　　　　1.去重，一个列表变成集合，就自动去重了。
           　　    2.关系测试，测试两组数据之间的交集、差集、并集等关系

作用：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

集合的方法

格式化输出：

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用的比较多

采用格式化输出，可以使得程序变得更加简洁美观

运算符

　　示例a=10, b=20

　　算术运算

　　比较运算

 　　赋值运算：

　　逻辑运算

　　成员运算

流程控制

　　单分支：

　　　　if 条件：
　　　　　　满足条件后要执行的代码块

if expression:
     if_suite

多分支：

　　　　　　if 条件：
　　　　　　　　满足条件后要执行的代码块
　　　　　　elif 条件：
　　　　　　　　上面的条件不满足就走这个
　　　　　　elif 条件：
　　　　　　　　上面的条件不满足就走这个

if expression:
    if_suite
elif:
    elif_suite
else:
    else_suite

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 ------

example

# 要求：
#
# 允许用户最多尝试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 ------

进制与转换

　取值范围：

　　　　二进制(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)

# 十六进制到十进制
int('f', 16)

# 等等等等，只需要把第一个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

字符编码

　　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、操作系统的语言设置