绪论

为什么学python

什么是TIBOE排行榜？

TIOBE排行榜是根据互联网上有经验的程序员、课程和第三方厂商的数量，并使用搜索引擎（如Google、Bing、Yahoo!）以及Wikipedia、Amazon、YouTube统计出排名数据，只是反映某个编程语言的热门程度，并不能说明一门编程语言好不好，或者一门语言所编写的代码数量多少。每月更新一次。

学习误区

如何成为python高手

1.循序渐进式学习

2.工程化思维-可迁移的底层编程能力

python涉及的领域

学习路径

求职面试经验

浅谈未来

为什么学习这门课程

学习方法

课程安排

项目实战

用户交互

编程入门

什么是编程
编程语言的划分
- 机器语言：二进制语言
- 汇编语言：一些英文标识
- 高级语言：与上两种的区别在于，高级语言建立在操作系统之上，而机器语言和汇编语言是不需要操作系统直接操作硬件的。

高级语言的分类

编译型：（相当于一本外文书籍翻译为中文再给你看）

高级语言编写代码，编译器进行编译，编译为可执行的二进制文件，计算机执行二进制文件。

如果对程序进行修改，需要在源文件上修改，再次编译，再在计算机上运行。
解释型：（相当于口译，一边说英文，一边翻译）

高级语言编写代码，解释器一行一行解释为机器语言，一边解释一边执行。

如果对程序进行修改，可以一边修改一边执行。

python介绍

python语言说明
python应用领域
python在公司的应用
使用python2还是python3

虽然业内很多企业还在大量使用python2.6/2.7，因为旧项目几十万甚至上百万行的代码想要快速升级到3.0不是一件容易的事情，但是大家开发新项目几乎都会用3.x。另外python3对比2.x做了许多改进。
安装python解释器
写程序的两种方式
- 进入解释器的交互模式：调试方便，但无法保存
- 脚本文件方式：永久保存代码

变量与常量

变量的概念

什么是变量

计算机工作过程直白的讲就是对数据的增删改查操作，那么数据一定是变化的，我们要储存变化的数据就要用变量。
- 变量，变化的量。变，变化，量，衡量状态
为什么要有变量

程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反应或者说是保存下来程序执行时的状态以及状态的变化。
python如何定义变量
- 变量名（相当于门牌号，指向值所在的空间），等号，变量值，是从右到左赋值。

python变量的定义规范
- 变量名只能字母、数字、下划线
- 变量名第一个字符不能是数字
- 关键字不能成为变量名
python变量的命名方式

驼峰体

驼峰体分为两种：

大驼峰：所有单词的首字母大写小驼峰：除第一个单词外，其他单词的首字母大写
```
# 大驼峰
AgeOfAlbert = 18

# 小驼峰
ageOfAlbert = 20
```
下划线（推荐使用）
```
age_of_albert = 22
```
定义变量名不好的方式
- 变量名为中文、拼音
- 变量名词不达意
- 变量名支持中文，但不能用中文
  
  在公司项目很大的时候，变量名的命名往往会很长，一方面是为了变量名不重复，另一方面是为了看到变量名就知道数据的含义。变量即逻辑
定义变量会有id（唯一标识号）、type（变量类型）、value（变量值）

等号比较的是value，is比较的是id

id相同，意味着type和value必定相同，value相同，type肯定相同，但id可能不通

常量

常量，不变的量。比如PI=3.1415925...或者程序运行过程中不变的量。python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写来代表常量。PI=3.1415926

基本数据类型

说明

python属于强类型的动态脚本语言。强类型，不允许不同类型相加动态。定义变量不用数据类型声明，且确定一个变量的类型是第一次给他赋值的时候。
字符串 str

使用单引号''、双引号""、三引号''' '''中间写内容定义的方式就是str类型，我们叫字符串类型。

print('hello world') # 字符串类型

我们不仅要知道他的数据类型是str，在学习一个数据类型时，还要知道他是一个可变类型还是不可变类型。
- 不可变类型：当变量值改变的时候id也会一起变化，相当于重新开辟一块内存空间，给变量重新赋值，原来的值是不可变的，str就是一个不可变类型。
- 可变类型：当变量值改变的时候，id可以保持不变，就相当于是在原来的基础上修改，位置还是没有变的。
整型 int

定义变量时，等号后面是整数数字，那么这个变量的类型就是int型，叫整型。整型是一个不可变类型。

age = 18
浮点型 float

定义变量时，等号后面是小数，那么这个变量的类型就是float型，叫浮点型。浮点型是一个不可变类型。

height = 1.82
列表 list

当我们需要存储一个班级里所有学生的名字的时候，就是用一个变量来存储多个值，以上三种数据类型都只能存储一个值，这种情况我们可以用list这种数据类型来完成，我们叫列表。定义形式：中括号内，多个元素用逗号分割，每个元素可以是任意的数据类型，列表是可变类型。
```
name = ['albert','james','kebo'] # 存储一个班级多个学生
info = ['albert','1.83','22'] # 存储一个人的信息
infos = [['albert','1.83','22'],['james','1.923','21'],['jerry','1.58','22']] # 存储多个人的信息
```
元组 tuple

和list类似的数据类型就是元组，他的用法与list相似，只是list可以修改，而元祖不能修改，它的定义方式是小括号内，多个元素逗号分割，每个元素可以是任意的数据类型。以上代码中括号改成小括号就可以。元组是一个不可变类型。
字典 dict

字典定义：花括号内多个元素逗号分割，每个元素按照key:value的形式，字典key只能用不可变类型，我们一般用字符串，字典是一个可变类型。
集合 set

集合定义：花括号内多个元素用逗号分割，每个元素可以是任意的数据类型，但是不能重复，集合是一个可变类型。
布尔 bloo

只有两个值，True False
补充匈牙利命令法

关于变量的命名，推荐使用匈牙利命令法,这也是工作中最为规范的变量命令方式，有时看一个人写的代码，只要看变量名就能粗略判断出它的水平。

简而言之。匈牙利命名法是把变量的类型缩写，放在变量名的最前面。关键在于，这里所说的变量类型，指的是那些和你的代码业务逻辑相关的类型。比如，在你代码里有两个变量，student和teacheers，他们分别代表的是用来存储学生的集合和存储老师的列表，使用匈牙利命名法。
```
students --> set_students
teachers --> list_teachers
```
很多情况下，使用匈牙利命名法是个不错的主意，因为它可以改善你的代码可读性，尤其在那些变量众多，同一类型多次出现，注意不要滥用。

注释

注释为了让自己和别人都看懂，增加代码可读性。

代码注释分为三种：

单行注释注释独占一行，以#开头，打一个空格，后面写注释内容
行内注释在代码尾部，打两个空格，打一个#，再打一个空格，后面写注释
多行注释用三对双引号注释内容 """注释内容"""

文件头

放在文件的顶部，这也是开发规范的细节

# 指定解释器
#!/usr/bin/env python 

# 指定文件编码
# -*- coding: utf-8 -*-

可以在pycharm配置每次新建文件会自动添加文件头。

用户交互

程序等待用户输入数据，再执行下一步操作，我们使用input来完成这个操作。

name = input('请输入您的姓名：') # 把用户的输入赋值给变量name
print('您好，'+name) # 用户输入完成后会打印用户的名字出来

python2 和python3的区别：

python3中的input：用户输入任何值，都存成字符串类型
python2中的input：用户输入什么类型，就存成什么类型
python2中的raw_input：等于python3的input

需要注意的是，当需要输入一个数字时，考虑到我们会用这个数字进行计算，而python3的input会默认转成str，所以我们需要把用户输入的数据转为int

age = input('请输入您的年龄')

age = int(age) #把str的age转化为int的age

流程控制

运算方式

数学运算计算机的核心部分是CPU,CPU有两个功能，控制和运算。计算机是如何进行运算的。

a = 10
b = 20
print(a + b) # 加
print(a - b) # 减
print(a * b) # 乘
print(a / b) # 除,值为0.5
print(a % b) # 取模,值为10
print(a ** b) # 幂
print(a // b) # 取整除，值为0

比较运算

返回结果为布尔值

print(a == b)
print(a != b)
print(a <> b) #已弃用
print(a > b)
print(a < b)
print(a >= b)
print(a <= b)

赋值运算

a = 10
b = 20
a = b # 把b的值赋给a
print(a) # 20
a += b # 等效于 a = a + b
a -= b # 等效于 a = a - b
a *= b # 等效于 a = a * b
a /= b # 等效于 a = a / b
a %= b # 等效于 a = a % b
a **= b # 等效于 a = a ** b
a //= b # 等效于 a = a // b

逻辑运算

print(True and False) # 与运算，都为True，结果才为True
print(True or False) # 或运算, 一个为True，结果就为True
print(not(True and False)) # 非运算,结果置非

身份运算

is 比较的是id,id为变量的内存地址，内存地址相同时才为True。

== 比较的是变量的value

分支语句

if,else

age=18
if age>=18:
    print('成年了')
else:
    print('小屁孩')

if循环嵌套使用

age=18
if age>=30:
    print("大叔")
else:
    if age>=18 and age<30:
        print("小鲜肉")
    else:
        print("小屁孩")

if,elif,else

age=18
if age>=30:
    print("大叔")
elif age>=18 and age<30:
    print("小鲜肉")
else:
    print("小屁孩")

循环语句

while循环 1.1 while循环(条件循环)

while 条件:
    # 循环体
    # 条件为真，执行循环体，再次重新判断条件的结果
    # 条件为假，不执行循环体，终止循环

1.2 猜拳游戏示例

albert_age=18
guess=int(input('>>:')) # 获取用户输入
while guess!=albert_age: # 如果用户输入不等于albert_age
    if guess>albert_age:
        print('猜大了')
    else:
        print('猜小了')
    guess=int(input('>>:'))
print('恭喜，猜对了')

1.3 while循环之死循环

死循环就是一直会执行的循环，因为条件一直成立。while True:

1.4 while循环嵌套与tag

tag是一个变量，不过它是布尔类型的，只有True或者False,你也可以写成0或者1，当我们有多层循环的时候，使用tag可以迅速退出所以循环。

tag=True
while tag:
    ...
    while tag:
        ...
        while tag:
            tag=False #循环逐层判断，当tag=False时，循环会逐层退出。

1.5 while循环break和continue

break：退出本层循环

continue：退出本次循环，继续下一次循环

上面的猜拳游戏可以写成：

albert_age=18
while True:
    guess=int(input('>>:'))
    if guess>albert_age:
        print('猜大了')
    elif guess<albert_age:
        print('猜小了')
    else:
        print('猜对了')
        break #用户猜对时，退出本层循环

1.6 while和else组合使用

其他语言中else一般与if搭配使用，在python中有while...else语句，while后面的else作用是，当while循环体正常执行完，中间没有被break中止的话，就会执行else后面的语句。

for循环

2.1 for循环（迭代循环）

for循环是迭代式循环，for遍历被循环的每一项内容。
```
for i in range(10):
    print(i)
```
range函数的使用方法：range(起始值,终止值,步长)

for会遍历range(10)中的每一个元素，0，1，2，3.....9

说明：
- 其中i为迭代出来的一个个对象。
- 关键字for和in是必须的。
- range(10)是一个被迭代的对象，只要能存多个值，他就可以被迭代，你直接写一个列表也是一样的
- 迭代循环可以理解被迭代的对象就是一个老母鸡，他肚子里是蛋。迭代出来的对象就是蛋。
2.2 for循环break和continue

（同while循环break和continue）

2.3 for循环与else连用

（同while循环与else连用）

流程控制语句用法说明

避免多层分支嵌套
封装过于复杂的判断逻辑
留意不同分支下的重复代码
使用“德摩根定律”
在判断条件中使用all()/any()
使用try/while/for中else分支
与None值做比较
留意and和or的运算优先级

数据类型

变量是用来反映/保持状态以及状态变化的，毫无疑问针对不同的状态要用不同的数据类型去标识。

数字类型

数字类型

1.1 数字类型int float

python中没有数字类型的概念，自己取的。

数字类型只能存一个值。是不可变类型，不可变类型可以哈希。
```
# int 整型
定义:age=10 # age=int(10)
用于标识：年龄、等级、身份证号、qq号、个数

# float 浮点型
定义：height=1.83
用于标识：身高、体重
```
1.2 int类型常用的方法
```
# 常用操作+内置方法
print(bin(3)) # 十进制转成二进制，0b11
print(oct(8)) # 十进制转成八进制，0o10
print(10) # 10
print(hex(16)) # 十进制转成十六进制，0x10
```
在于用户交互时，我们常用.isdigit()这个判断用户输入是不是数字，来进行下一步操作，这样就避免程序出错，但是需要注意的是用户输入的内容默认是字符串，判断一个字符串是不是数字，我们使用这个方法。
```
age=input('请输入年龄：')

if age.isdigit():
    age=int(age)
else:
    print('输入的不是数字')
```
1.3 python其他数据类型(了解)

字符串类型

字符串类型

加了引号的的字符，就是字符串类型，用于标识：描述性内容，如姓名、性别、国籍。定义形式：name='albert' # name=str('albert')

字符串格式化
```
name=input('请输入你的名字：')
print('您好，%s' % name) # %s可以理解为占位符，在输出时
```
单引号、双引号、三引号的区别

没有任何区别，除了再下面这种情况：

区别字符串中的字符串
```
msg="My name is Albert,I'm 18 year old"
```
多行字符串必须用多引号
```
msg=
'''
你好呀
今年结婚了吗
'''    
```

字符串拼接

# 数字可以进行加减乘除运算，字符串可以进行"加"、"乘"运算

name='Albert'
age='18'
print(name+age) # 实际是字符串的拼接
print(name*5) # 实际是5个字符串拼接

字符串类型只能存一个值，是不可变类型，可以哈希。

字符串类型常用的方法

4.1 按照索引取值

字符串是不可变类型，并不能改变字符串的值，取值时最多可以有三个参数，分别是起始位置、结束位置、步长，可以正向取值，也可以反向取值。

hobbies="music basketball"
print(hobbies[0])
print(hobbies[5])
print(hobbies[0:5])
print(hobbies[:5])
print(hobbies[0:5:2]) # 从第0个元素到第4个元素，隔1个元素取一个 
print(hobbies[0:5:-2]) # 取不到元素，因为从第0个元素到第4个元素，逆序隔1个元素取一个
print(hobbies[-1]) # 取倒数第一个元素
print(hobbies[-2]) # 取倒数第二个元素

4.2 长度运算

print(len('name')) # 可用来求strin类型、列表等的长度

4.3 成员运算

print('a' in 'Albert') # False 判断a是否在Albert中，在则返回True，否则返回False
print('a' not in 'Albert') # True

4.4 移除空白

print('   name'.lstrip()) # 移除左边空白
print('name  '.rstrip()) # 移除左边空白
print('   name  '.strip()) # 移除两边空白

4.5 切分

str1='kobe 22 lakes'
print(str1.split(' ')) # ['kobe', '22', 'lakes']
str2='kobe,22 lakes,akes'
print(str2.split(',',1)) # ['kobe', '22 lakes,akes'],数字代表分隔次数

4.6 组合

#指定字符连接序列中元素后生成的新字符串，join内是要连接的元素序列。
print('ab',join('1234')) #1ab2ab3ab4
# 可迭代的对象必须是字符串
print(' '.join(['HELLO','L','O','V','E'])) # HELLO L O V E

4.7 替换

name='Albertabcde'
print(name,replace('e','YAYA',2)) # AlbYAYArtabcdYAYA # 数字是替换次数
print(name) # Albertabcde # name的值并没有变

4.8 字符串的其他操作

# find,rfind,index,rindex,count
str1='hello world'
print(str1.find('l',0,4)) # 2 ,顾头不顾尾，找不到则返回-1，找到返回下标
print(str1.find('l',4,-1)) # 9 
print(str1.index('l',0,3)) # 2 同上，但是找不到会报错
print(str1.count('e',1,3)) # 1  如果不指定范围则查找所有

# center,ljust,rjust,zfill
name='Albert'
print(name.center(30,'~')) # ~~~~~~~~~~~~Albert~~~~~~~~~~~~
print(name.ljust(30,'*')) # Albert************************
print(name.rjust(30,'/')) # ////////////////////////Albert
print(name.zfill(30)) # 000000000000000000000000Albert,用0填充 

# expandtabs
# 字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是8
say_hello='Albert\thello'
print(say_hello.expandtabs(2)) # Albert  hello
print(say_hello.expandtabs(20)) # Albert              hello

# capitalize,swapcase,title

letter='abc ABC hello'
print(letter.capitalize()) # 首字母大写
print(letter.swapcase()) # 大小写转换
print(letter.title()) # 每个单词首字母大写

# is数字系列
num1=b'4'
print(type(num1))
num2=u'4'
print(type(num2))
num3='四'
print(type(num3))
num4='IV'
print(type(num4))
# isdigit()
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())

# isdecimal() ：unicode
# 检查字符串是否只包含十进制字符。这种方法只存在于unicode对象
# 定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可
# bytes类型没有isdecimal() 方法
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False

# isnumeric() :unicode 中文数字
# 检测字符串是否只由数字组成。
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # False

# 三者都不能判断浮点数

列表

列表类型基本介绍

列表类常用的方法

2.1 添加元素

append方法在列表最后追加元素
insert方法在列表中插入元素

extend方法在列表最后追加元素，必须是可迭代对象

l1=['a','b','c','d']
l1.append('e')
print(l1) # ['a', 'b', 'c', 'd', 'e']
l1.insert(3,'bb')
print(l1) # ['a', 'b', 'c', 'bb', 'd', 'e']
l1.extend([1,2,3])
print(l1) # ['a', 'b', 'c', 'bb', 'd', 'e', 1, 2, 3]

2.2 删除对象

pop删除，有返回值，默认删除列表中最后一个，指定删除索引值

l2=[1,2,3,4,5,6]
print(l2.pop()) # 6
print(l2.pop(0)) # 1
print(l2) # [2, 3, 4, 5]

remove删除,没有返回值，没有默认值，指定被删除的元素

l2=[1,2,3,4,5,6]
print(l2.remove(1)) #None ，没有返回值
print(l2) # [2, 3, 4, 5, 6] ,删除的不是索引值为1，而是元素值为1的元素

clear删除,保留列表名称，清空里面的值

l2=[1,2,3,4,5,6]
print(l2.clear()) #None
print(l2) # []

del删除,通用删除，一般不用

l2=[1,2,3,4,5,6]
del(l2[0]) # 按索引值删除
print(l2) # [2, 3, 4, 5, 6]
del l2 # 在内存中删除l2,相当于没有定义l2
print(l2) # 报错

2.3 更改元素,替换元素

l2=[1,2,3,4,5,6]
l2[0]=10
print(l2) # [10, 2, 3, 4, 5, 6]

2.4 查找元素，按照索引或者指定元素查找

2.5 统计长度

l2=[1,2,3,4,5,6]
print(len(l2)) # 6

2.6 统计元素个数

l2=[1,2,3,4,5,6,2,2]
print(l2.count(2)) # 3

2.7 排序

# reverse 反序排序
l2=[1,2,3,4,5,6,2,2]
l2.reverse()
print(l2) # [2, 2, 6, 5, 4, 3, 2, 1]

# sort 按照ascii码进行排序
l2.sort()
print(l2) # [1, 2, 2, 2, 3, 4, 5, 6]

2.8 复制列表

l2=[1,2,3,4,5,6,2,2]
print(l2.copy()) #  [1,2,3,4,5,6,2,2]
print(l2)

2.9 在python中的赋值、浅拷贝和深拷贝的区别

总结：

元组

与列表类型相比，非常类似，[]换成(),作用：用于存储多个值，对比列表来说，元组不可变（是可以当做字典的key的），不可更改，主要是用来读。

age=(11,22,33) 
#本质是age=tuple((11,22,33))

元组可以存储多个值，是有序的，是不可变型，可以哈希。元组常用的方法，请参考列表常用的方法，需注意元组只能取值，只能改变值。

字典

字典类型的基本介绍

字典类型常用方法

2.1 增加元素

通过键值对

用fromkeys构造字典

dict1={'name':'albert','age':13,'sex':'男'}
dict1['sign']='一个懒人'
print(dict1) # {'name': 'albert', 'age': 13, 'sex': '男', 'sign': '一个懒人'}

seq=('father','mather')
a=dict1.fromkeys(seq) 
print(a) # {'father': None, 'mather': None}

b=dict1.fromkeys(seq,'10')
print(b) # {'father': '10', 'mather': '10'}

2.2 删除元素

del 通过字典key删除键值对
pop 通过字典key删除键值对，有返回值

popitem 随机删除字典中的一对键和值,一般删除末尾对

del b['father']
print(b) # {'mather': '10'}
res=a.pop('father') # 有返回值
print(a) # {'mather': None}
res2=dict1.popitem() # {'name': 'albert', 'age': 13, 'sex': '男'}
print(dict1)

2.3 更改元素

通过键值对的方式
setdefault 只添加，不修改

update 即添加，也修改

dict1['sex']='女'
print(dict1) # {'name': 'albert', 'age': 13, 'sex': '女', 'sign': '一个懒人'}

a.setdefault('grandefather','200')
a.setdefault('father','200') # 不生效
print(a) # {'father': None, 'mather': None, 'grandefather': '200'}

b.update({'grandefather':'100','father':'200'})
print(b) # {'father': '200', 'mather': '10', 'grandefather': '100'}

2.4 查找元素

通过键值对查找
通过get方法查找
通过enumerate枚举
通过.keys() 、.values()、.items()

通过for循环遍历

res1=dict1['sex']
print(res1) # 男

res2=dict1.get('sex')
print(res2) # 男

for a in enumerate(dict1):
    print(a)

print(dict1.keys()) # dict_keys(['name', 'age', 'sex', 'sign'])
print(dict1.values()) # dict_values(['albert', 13, '男', '一个懒人'])
print(dict1.items()) # dict_items([('name', 'albert'), ('age', 13), ('sex', '男'), ('sign', '一个懒人')])

for k,v in dict1.items():
    print(k,v)

2.5 成员运算与长度运算

参考列表的运算方法，成员运算的依据是字典的key，而不是value

成员运算：in、not in

集合

花括号内，多个元素用逗号隔开，用来储存多个值，并且是无序的，那么这多个值不能用来取值，但是我们可以使用它来进行去重（比如去掉列表中重复的元素）和关系运算。

集合的元素遵循的三个原则：

每个元素必须是不可变类型（可作为字典的key）
没有重复的元素
无序

注意集合的目的是将不同的值存放在一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

集合类型可以存多个值，是无序的，是可变类型，不可以哈希。

pinao={'刘德华','周杰伦','王力宏','albert','孙悟空'}
violin={'猪八戒','郭德纲','周杰伦'}

# 报名钢琴课程，又报名小提琴课程的同学
print(pinao&violin) # {'周杰伦'}
# 报名了的所有同学
print(pinao|violin) # {'孙悟空', '周杰伦', '刘德华', '王力宏', '郭德纲', '猪八戒', 'albert'}
# 只报名了钢琴课的同学
print(pinao-violin) # {'albert', '孙悟空', '刘德华', '王力宏'}
# 没有同时报名两门课的同学
print(pinao^violin) # {'孙悟空', '刘德华', '郭德纲', '王力宏', 'albert', '猪八戒'}

布尔类型

人脑的主要作用是数据运行与逻辑运算，此处的布尔类型就模拟人类的逻辑运算，即判断一个条件成立时，用True标识，不成立用False标识。

所有数据类型都自带布尔值：
1. None,0,空（空字符串，空列表，空字典等）三种情况下布尔值是False
2. 其余均为真
可变类型与不可变类型
1. 可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表、字典
2. 不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存控件）

collections容器数据类型

字符编码

理解字符编码理论储备知识

字符编码说明

计算机运行应用软件原理计算机的运行与哪些核心部件有关：

CPU：运行程序

内存：临时存储数据，一个软件想要运行，必须先加载到内存

硬盘：软件的数据要想永久保存，必须存入硬盘中

一个软件的启动过程：

应用程序存放在硬盘上
应用程序从硬盘读入到内存
CPU调用内存中与该应用软件相关的数据进行处理

保存文件的原理

执行python程序的原理

字符编码介绍

字符编码初登场计算机是基于电工作的，高电平用数字1表示，低电平用数字0表示，计算机只能识别010101，即二进制，计算机的工作原理就是基于二进制工作的。我们平时在使用计算机的时候并不使用二进制控制，使用的是人类字符，但是这些人类字符计算机是看不懂的，要让计算机看懂，必先经历一个过程：

人类字符 ==> 翻译 ==> 二进制数字

我们在notepad程序中写一个“你好”，就把这个内容写入到内存中，计算机想要识别必先经历一个翻译的过程，当然不是随便翻译，在取这个数据时仍需按照二进制数字与人类的字符一一对应的取出来，所以必须要遵循一个标准，这个标准就是字符编码表。我们在notepad程序中写一个“hello world”,在计算机内部已经事先存好了这张表，每一个字母（包括大写、小写字母）和空格回撤标点这些东西都对应一个数字，然后再把这些数字转化为二进制，这样一个字符就会对应一个二进制数字，也就是完成写入的过程。当打印的时候再反过来，一组二进制数字对应一个字符。所以，我们就清楚了内存上应该有这样一张字符编码表，早期的时候硬盘上保存的也是二进制，所以硬盘上无需有字符编码表。

字符编码发展史

乱码问题的产生与解决

乱码的成因写入和读取时的字符编码不一致。

比如写用utf-8，读取时用ascii码,就会产生乱码

保证不乱码的方案

保证文件写入和读取时的字符编码一致。

人为制造的乱码

python中字符编码问题

解释器读取文件时字符编码异同

文件头的作用就是告诉python解释器用指定的编码去读取文件内容。在pycharm中，当我指定好了读取文件的字符编码，它会自动改变保存写入到硬盘的字符编码中。

解释器执行文件时字符编码异同

utf-8 英文2个字节，中文3个字节，生僻字4个字节

字符编码的转换

python2两种字符串类型的区别

字符编码的保存与取值原理

6. 字符编码的总结

文件处理

文件读写基本操作

文件操作的工作流程

一个完整的计算机系统：1. 应用程序 2.操作系统 3. 计算机底层硬件

如果应用程序需要操作硬件，必须发指令给操作系统，通过操作系统来帮应用程序完成对机器硬件的操作。如果应用程序需要把自己生产的数据永久保存起来（应用程序产生的数据原本是在内存内）那么就是把他写入硬盘，同样是向操作系统发起请求，最后由操作系统返回文件内容，这之间的过程如下图所示：
文件操作的基本形式