第0篇 Python前言

1.编译型与解释型

编译型：一次性编译成2进制，再执行
优点：执行效率高
缺点：不能跨平台，开发效率低
代表语言：C
解释型：逐行解释成二进制，再执行
优点：可以跨平台，开发效率高
缺点：执行效率低。
代表语言：python

2.运行python代码

在d盘下创建一个t1.py文件内容是：

print('hello world')

打开windows命令行输入cmd，确定后写入代码python d:t1.py，即可运行python。

3. 解释器

如果想要类似于执行shell脚本一样执行python脚本，例： ./t1.py ，那么就需要在 hello.py 文件的头部指定解释器，如下：

#!/usr/bin/env python

print "hello,world"

如此一来，执行： ./t1.py 即可。

ps：执行前需给予t1.py 执行权限，chmod 755 t1.py

4.注释

1）注释的作用：

用自己熟悉的语言在代码中添加注释，方便后期自己查看和理解，也方便其他人查看和理解代码含义。

2）单行注释：

以#号开头，#后面的所有内容均不会被程序执行，起到辅助说明的作用。

 # 这是一行注释，不会被程序执行
 print("hello world")

说明：为了保证代码的可读性，#后面建议先添加一个空格，然后再添加说明文字。

也可以在代码后面添加注释，为了保证代码的可读性，建议#号和代码之间至少两个空格。

 # 这是一行注释，不会被程序执行
 print("hello world")  # 这是一行注释

3）多行注释：

如果需要添加的注释文字比较多，可以使用多行注释，以"""号开头，以"""号结尾，中间的文字为需要注释的文字。

 """
 这是
 多行
 注释
 """
 print("hello world")  # 这是一行注释

5.缩进（代码块）

Python的代码块不使用大括号{}来控制，Python最具特色的就是使用缩进来写模块。缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个是严格执行的。

a.按照约定俗成的管理，应该始终使用4个空格的缩进；

b.很多Python程序员建议每行不超过80个字符。

c.要将程序的不同部分分开，可以使用空行，但程序中不要使用过多的空行。

多个语句构成代码块：

a.Python中的换行即表示一个语句结束。

b.缩进相同的一组语句构成一个代码块。

c.像if，while，def和class等复合语句，首行以关键字开始，以冒号：结束，该行之后的一行或多行缩进代码构成代码块。

6.一行和多行

同一行显示多条语句

Python可以在同一行中使用多条语句，语句之间使用分号分割。

一条语句以多行来书写

Python语句一般以新行作为语句的结束符，但是可以使用斜杠(\)将一行的语句分为多行显示，如果语句中包含[]，{}，()就不需要使用多行连接符了。

aa = ["spring", "summer", "autumn",
      "winter"]

7.引号

Python可以使用单引号，双引号，三引号来表示字符串，引号的开始与结束必须使用相同类型的，其中三引号可以由多行组成，在文件的特定地点，三引号可以被当做注释。

8.变量的基本使用

在Python中每个变量在使用前必须赋值，变量赋值以后该变量才会被创建，等号用来给变量赋值。

 # coding=utf-8

 qq_number = ""  # 定义qq号码变量
 qq_password = ""  # 定义qq密码变量

 print(qq_number)
 print(qq_password)

 -----输出结果-----
 123456789
 12345

说明：

1)变量名只有在第一次出现才是定义变量，变量名再次出现，是直接使用之前定义过的变量（相同的作用域）。

2)Python中定义变量不需要指定变量的类型，运行的时候根据解释器，自动推导出变量中保存数据的准确类型。

3)变量名可以有字母、数字、下划线组成，不能以数字开头，不能与关键字重名。

4)Python中变量名是区分大小写的。

5)在定义变量时，为了保证代码格式，=的左右两边应该个保留一个空格。

6)以下划线开头的变量名都是有特殊意义的：

　　a.以单下划线开头_foo代表不能直接访问的类属性，需要通过类提供的接口进行访问，不能用from xxx import *导入；

　　b.以双下划线开头的__foo代表类的私有成员，以双下划线开头和结尾的__foo__代表Python里特殊方法专用的标志，如__init__()代表类的构造函数。

7)在Python中，如果变量名有两个或多个单词组成，可以按如下方式命名：

　　a.每个单词都使用小写字母。

　　b.单词与单词之间使用_下划线连接。　

9.常量

常量即指不变的量，如pai 3.141592653..., 或在程序运行过程中不会改变的量

举例，假如小米的年龄会变，那这就是个变量，但在一些情况下，他的年龄不会变了，那就是常量。在Python中没有一个专门的语法代表常量，程序员约定俗成用变量名全部大写代表常量

AGE_OF_PP = 

说明：在c语言中有专门的常量定义语法，const int count = 60;一旦定义为常量，更改即会报错。

10.关键字

关键字是Python内部已经使用的标识符，我们定义的变量不能与标识符重名。

通过以下命令查看Python中的关键字：

 import keyword
 print(keyword.kwlist)

 ------输出结果------
 ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

 11.变量的引用

变量和数据是分开存储的，数据保存在内存中的一个位置，变量中保存着数据在内存中的地址，叫做引用，使用id()函数可以查看变量中保存数据所在的内存地址，另外，如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用。

函数传递的本质是实参保存数据的引用，而不是实参保存的数据。

 def test(num):
     print("在函数内部%d对应的内存地址是%d" % (num, id(num)))

 a = 

 print("a对应的内存地址是%d" % id(a))
 test(a)

在函数内部返回，实际上返回的是数据的引用，而不是数据本身。

 def test():
     result = "hello"
     print("在函数内部变量 %s 的内存地址为 %d " % (result, id(result)))
     return result

 a = test()
 print("变量a的内存地址为 %d " % id(a))

Python中参数传递采用的是“传对象引用”的方式，如果函数收到的是一个可变对象（列表或者字典）的引用，就能修改对象的原始值，如果函数收到的是一个不可变对象（元组，数字，字符串等）的引用，就不能直接修改原始对象。变量和数据都是保存在内存的，但是变量和数据分开保存，数据保存在内存，变量中保存着数据在内存的地址，变量中记录数据的地址叫做引用，可以使用id()函数查看变量的地址。另外，不可变数据类型有元组，字符串，数字类型int，bool，float，complex，long等，可变的数据类型由列表，字典。

在我们使用字典时，字典的key值只能是使用不可变数据类型。

 # .字符串引用
 a = ''
 b = a
 a = 'hello'
 print("a:", a)
 print("b:", b)
 print("a的内存地址：", id(a))
 print("b的内存地址：", id(b))
 # .列表的引用
 a = [, , , ]
 b = a
 b[] =
 print("a:", a)
 print("b:", b)
 print("a的内存地址：", id(a))
 print("b的内存地址：", id(b))

 -------输出结果-------
 a: hello
 b:
 a的内存地址：
 b的内存地址：
 a: [, , , ]
 b: [, , , ]
 a的内存地址：
 b的内存地址： 

 12.局部变量和全局变量

局部变量是在函数内部定义的变量，只能在函数内部使用，全局变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量。

在函数内部，可以通过全局变量的引用获取对应的数据，但是，不允许直接修改全局变量的引用。

 num = 10

 def func1():
     num = 90  # 在函数内部定义了一个局部变量
     print("func1==>%d" % num)

 def func2():
     print("func2==>%d" % num)

 func1()
 func2()

 --------输出---------
 func1==>90
 func2==>10

在函数内部修改全局变量，可以使用global关键字。

 num = 10

 def func1():
     global num # global关键字会告诉解释器后面的变量是一个全局变量，在使用赋值语句时，就不会创建局部变量。
     num = 90
     print("func1==>%d" % num)

 def func2():
     print("func2==>%d" % num)

 func1()
 func2()

 --------输出结果-------
 func1==>90
 func2==>90

全局变量命名的建议：

全局变量名应该增加g_或者gl_的前缀。

13.输出（print）

Python3的输出使用print函数，分为换行输出和不换行输出，在print()的括号中加上字符串，就可以向屏幕上输出指定的文字，括号中还可以放表达式。

1.换行输出：print（）默认的输出是换行的。

2.不换行输出：将括号里的所有参数输出在一行，只需要在每一个参数后面加一个，即可。最后一个参数后面没有逗号，参数之间的逗号，输出来之后是空格。

3.循环输出变量的时候，如果不换行，后面可以加上end=' '，即print(b,end=' ')

输出时常用的函数：

str():将对象转化为适于人阅读的形式，返回一个对象的string形式。

repr():将对象转化为供解释器读取的形式，返回对象的string形式，可以输出包括转义字符在内的所有字符。

str.format():格式化输出。

# -*- coding:utf- -*-

x  = "abcde\nf\ng"

print(str(x))
print(repr(x))

---------输出结果----------
abcde
f
g
'abcde\nf\ng'

str.format()格式化字符串：

1.在括号中的数字用于指向传入对象的format()中的索引位置：

print("{0}和{1}".format("zhangsan", "lisi"))

2.format()中使用了关键字参数，它们的值会指向使用该名字的参数。

print("{0}和{1}和{other}".format("zhangsan", "lisi", other="wangwu"))

14.程序交互（input）

函数input()让程序暂停运行，等待用户输入一些文本，获取用户输入后，将其值存储到一个变量中，可以方便使用。

#!/usr/bin/env python
# -*- coding: utf- -*-
name = input("What is your name?")
age = input("How old are you?")
hometown = input("Where is your hometown?")

print("Hello ",name , "your are ", age , "years old, you came from",hometown)

15.格式化输出

现有一练习需求，问用户的姓名、年龄、工作、爱好 ，然后打印成以下格式

------------ info of 博小园  -----------
Name  : 博小园
Age   : 22
job   : Teacher
Hobbie: girl
------------- end -----------------

只需要把要打印的格式先准备好， 由于里面的 一些信息是需要用户输入的，你没办法预设知道，因此可以先放置个占位符，再把字符串里的占位符与外部的变量做个映射关系就好啦

name = input("Name:")
age = input("Age:")
job = input("Job:")
hobbie = input("Hobbie:")

info = '''
------------ info of %s ----------- #这里的每个%s就是一个占位符，本行的代表后面括号里的name
Name  : %s  #代表 name
Age   : %s  #代表 age
job   : %s  #代表 job
Hobbie: %s  #代表 hobbie
------------- end -----------------
''' %(name,name,age,job,hobbie)  # 这行的 % 号就是把前面的字符串与括号后面的变量关联起来 

print(info)

%s就是代表字符串占位符，除此之外，还有%d,是数字占位符， 如果把上面的age后面的换成%d，就代表你必须只能输入数字啦

age     : %d

我们运行一下，但是发现出错了。。。

说%d需要一个数字，而不是str, 我们明明输入的是数字呀，22，22呀。

不用担心 ，不要相信你的眼睛我们调试一下，看看输入的到底是不是数字呢？怎么看呢？type()

name = input("Name:")
age = input("Age:")
print(type(age))

执行输出是：

Name:boxiaoyuan
Age:
<class 'str'> #怎么会是str
Job:IT

让我大声告诉你，input接收的所有输入默认都是字符串格式！

要想程序不出错，那怎么办呢？简单，你可以把str转成int

age = int(input("Age:"))
print(type(age))

肯定没问题了。相反，能不能把数字转成字符串呢？必然可以，str(yourStr)

问题：现在有这么行代码

msg = "我是%s,年龄%d,目前学习进度为80%" % ('金鑫',18)
print(msg)

这样会报错的，因为在格式化输出里，你出现%默认为就是占位符的%，但是我想在上面一条语句中最后的80%就是表示80%而不是占位符，怎么办？

msg = "我是%s,年龄%d,目前学习进度为80%%" %('金鑫',18)
print(msg)

这样就可以了，第一个%是对第二个%的转译，告诉Python解释器这只是一个单纯的%，而不是占位符。

16.编码的初识

计算机需要存储数据和通过网络传输数据，计算机存储在磁盘中的数据或者通过网络发送的数据本质发送的都是bit流也就是所谓的01010101101，那么这些010010是需要与咱们熟知的文字有标准的对应关系，这样咱们才可以识别这些数据。计算机起初使用的密码本是：ASCII码（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统。ASCII码中只包含英文字母，数字以及特殊字符与二进制的对应关系，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256，所以，ASCII码最多只能表示 256 个符号。

# 思考：python中一个字符串为 'abc'，那么如果用ASCII码编码，这个字符串占几个字节？

# ASCII码 一个字符用一个字节表示，所以字符串'abc'占三个字节,'abc'如果存储在磁盘中其实存储的是：     

随着计算机的发展. 以及普及率的提高. 流⾏到欧洲和亚洲. 这时ASCII码就不合适了. 比如: 中⽂汉字有几万个. 而ASCII 多也就256个位置. 所以ASCII不行了. 怎么办呢? 这时, 不同的国家就提出了不同的编码用来适用于各自的语言环境（每个国家都有每个国家的GBK，每个国家的GBK都只包含ASCII码中内容以及本国自己的文字）. 比如, 中国的GBK, GB2312, BIG5, ISO-8859-1等等. 这时各个国家都可以使用计算机了. 
GBK：只包含本国文字（以及英文字母，数字，特殊字符）与0101010对应关系。

经实际测试和查阅文档，GBK是采用单双字节变长编码，英文使用单字节编码，完全兼容ASCII字符编码，中文部分采用双字节编码。

对于ASCII码中的内容，GBK完全沿用ASCII码，所以一个英文字母（数字,特殊字母）用一个字节表示，而对于中文来说，一个中文用两个字节表示。

# 思考：python中一个字符串为 'a太白'，那么如果用GBK码编码，这个字符串占几个字节？

#一个英文用一个字节，一个中文用两个字节，所以：'a太白' 如果是GBK编码占5个字节。

但是GBK只包含中文，不能包含其他文字，言外之意，GBK编码是不能识别其他国家的文字的，举个例子：如果你购买了一个日本的游戏盘，在用中国的计算机去玩，那么此时中国的计算机只有gbk编码和ascii码，那么你在玩游戏的过程中，只要出现日本字，那就会出错或者出现乱码.......

但是，随着全球化的普及，由于网络的连通，以及互联网产品的共用（不同国家的游戏，软件，建立联系等），各个国家都需要产生各种交集，此时急需一个密码本：要包含全世界所有的文字与二进制0101010的对应关系，所以创建了万国码：

Unicode： 包含全世界所有的文字与二进制0101001的对应关系。

起初：Unicode规定一个字符用两个字节表示：

　　英文:  a b c  六个字节   一个英文2个字节

　　中文   中国   四个字节  一个中文用2个字节

但是这种也不行，这种最多有65535种可能，可是中国文字有9万多，所以改成一个字符用四个字节表示：.

　　a  01000001 01000010 01000011 00000001

　　b  01000001 01000010 01100011 00000001

　　中 01001001 01000010 01100011 00000001

这样虽然解决了问题，但是又引出一个新的问题就是原本a可以用1个字节表示，却必须用4个字节，这样非常浪费资源，所以对Uniocde进行升级。

UTF-8:包含全世界所有的文字与二进制0101001的对应关系（最少用8位一个字节表示一个字符）。

UTF-8 ：最少用8位数去表示一个字符：

　　　　　　英文:           8位，1个字节。

　　　　欧洲文字:         16位，两个字节表示一个字符。

　　中文,亚洲文字:       24位，三个字节表示.。

# 思考：python中一个字符串为 'a太白'，那么如果用UTF-8码编码，这个字符串占几个字节？

#一个英文用一个字节，一个中文用三个个字节，所以：'a太白' 如果是UTF-8编码占7个字节。

单位之间的转换：

8bit = 1bytebyte = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
1024TB = 1PB
1024TB = 1EB
1024EB = 1ZB
1024ZB = 1YB
1024YB = 1NB
1024NB = 1DB
常⽤到TB就够了

总结：

1、ASCII码中只包含英文字母，数字以及特殊字符与二进制的对应关系，主要用于显示现代英语和其他西欧语言，其最多只能用 8 位来表示（一个字节），ASCII码最多只能表示 256 个符号。

2、GBK：只包含本国文字（以及英文字母，数字，特殊字符）与0101010对应关系。一个英文字母（数字,特殊字母）用一个字节表示，而对于中文来说，一个中文用两个字节表示。

3、Unicode： 包含全世界所有的文字与二进制0101001的对应关系。起初：Unicode规定一个字符用两个字节表示，后来改成一个字符用四个字节表示。

4、UTF-8：包含全世界所有的文字与二进制0101001的对应关系。英文--8位--1个字节；欧洲文字--16位--两个字节表示一个字符；中文--亚洲文字--24位--三个字节表示.。