本文共 13894 字，大约阅读时间需要 46 分钟。

1.Python变量的类型

用type(变量的名字)来查看变量的类型

#!/usr/bin/python3 a = 10b = 10.0c = True# ./test.py 
    
     
     
    
   

2.格式化符号

在程序中%这样的符号是python的格式化输出

#!/usr/bin/python3 age = 18name = "Tom"print("My name is %s and I am %d years old"%(name,age))# ./test.py My name is Tom and I am 18 years old

在输出的时候如果有\n，则\n后的内容将换行输出

练习：完成以下名片的打印

#!/usr/bin/python3 name = input("please input your name")qq = input("please input your qq number")tel = int(input("please input your telephone num"))address = input("please input your company address")print("===================================")print("name:%s"%name)print("QQ:%s"%qq)print("telephone:%d"%tel)print("address:%s"%address)print("===================================")# ./test.py please input your nameDaemonplease input your qq number156841028please input your telephone num12659874562please input your company addresstianfupark===================================name:DaemonQQ:156841028telephone:12659874562address:tianfupark===================================

知识点：input() 它接受表达式输入，并把表达式的结果给等号左边的变量

3.运算符

1）算术运算符

>>> a = 10>>> b = 20>>> a+b30>>> a-b-10>>> a*b200>>> a/b0.5>>> a//b0>>> a%b10>>> a**b100000000000000000000

2）赋值运算符 =

把=号右边的结果给左边的变量赋值

>>> a,b = 10,20>>> a10>>> b20

3）复合赋值运算符

4）比较（关系）运算符 5）逻辑运算符 6）常用的数据类型转换

4.判断语句

1）if判断语句

if 要判断的条件： 条件成立时，要做的事情

#!/usr/bin/python3 age = int(input("please input your age:"))if age >= 18:    print("You can play games")# ./test.py please input your age:18You can play games# ./test.py please input your age:17

2)if - else

if 条件： 满足条件时要做的事情1 满足条件时要做的事情2 满足条件时要做的事情3 else: 不满足条件时要做的事情1 不满足条件时要做的事情2 不满足条件时要做的事情3

#!/usr/bin/python3 age = int(input("please input your age:"))if age >= 18:    print("You can play games")else:    print("You are so young do homework")# ./test.py please input your age:19You can play games# ./test.py please input your age:10You are so young do homework

3)elif

if xxx1: 做事情1 elif xxx2: 做事情2 elif xxx3: 做事情3

#!/usr/bin/python3 score = int(input("please input your score:"))if score>=90 and score <= 100:    print("Your level is A")elif score>=80 and score <90:    print("Your level is B")elif score>=70 and score <80:    print("Your level is C")elif score>=60 and score <70:    print("Your level is D")else:     print("Your level is E")# ./test.py please input your score:100Your level is A# ./test.py please input your score:60Your level is D# ./test.py please input your score:40Your level is E

练习：猜拳游戏

#!/usr/bin/python3 import randomplayer = int(input("please input:剪刀(0) 石头(1) 布(2)"))computer = random.randint(0,2)if(((player==0)and(computer==2)) or ((player==1)and(computer==0)) or((player==2)and(computer==1)) ):    print("You Win, You'are so Good!")elif player==computer:    print("equal ,again...")else:    print("You lose,come on...")# ./test.py please input:剪刀(0) 石头(1) 布(2)0You Win, You'are so Good!# ./test.py please input:剪刀(0) 石头(1) 布(2)0You Win, You'are so Good!# ./test.py please input:剪刀(0) 石头(1) 布(2)0You lose,come on...# ./test.py please input:剪刀(0) 石头(1) 布(2)0You lose,come on...

需要多次重复执行的代码可以用循环来完成

1）while循环 while 条件： 条件满足时，做的事情1 条件满足时，做的事情2

#!/usr/bin/python3 i = 0while i < 5:    print("i=%d"%i)    i+=1# ./test.py i=0i=1i=2i=3i=4

计算1到100的累积和

#!/usr/bin/python3 i = 0sum = 0while i <= 100:    sum += i    i+=1# ./test.py the sum of 1 from 100 is:5050

while嵌套:9*9表

#!/usr/bin/python3 i=1while i<=9:    j = 1    while j<=i:        print("%d*%d=%d "%(i,j,i*j),end="")        j+=1    print("\n")    i+=1# ./test.py 1*1=1 2*1=2 2*2=4 3*1=3 3*2=6 3*3=9 4*1=4 4*2=8 4*3=12 4*4=16 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81

2) for 循环

for循环可以遍历任何序列的项目，如一个列表或者一个字符串 for 临时变量 in 列表或者字符串: 循环满足条件时执行 else: 循环不满足条件时执行

#!/usr/bin/python3 name = "DangGo"for x in name:    print(x)# ./test.py DangGo

break:用来结束整个循环

continue:用来结束本次循环，紧接着执行下一次的循环 注意：break/continue只能用在循环中，不能单独使用 break/continue在嵌套循环中，只对最近的一层循环起作用

4.字符串

双引号或者单引号中的数据，就是字符串

1）下标索引 字符串实际上就是字符的数组，支持下标索引 如果想取出部分字符，可以通过下标的方法，python中下标从0开始

name = "DangGo"print(name[0])print(name[1])print(name[2])print(name[3])# ./test.py Dang

2）切片

切片是指对操作的对象截取其中一部分的操作 [起始：结束：步长] 注意：选取的区间属于左闭右开型，从起始位开始，到结束位的前一位结束，不包结束位本身

name = "DangGo"print(name[0:3]) #起始0，结束3不包含3# ./test.py Dan

3)字符串常见操作

find:检测str是否包含在mystr中，如果是返回开始的索引值，否则返回-1

name = "My name is Tom str hao bao hao"pos = name.find("Tom")print(pos)# ./test.py 11

index:跟find()方法一样，如果str不在mystr中会报一个异常

name = "My name is Tom str hao bao hao"pos = name.index("Tomz")print(pos)# ./test.py Traceback (most recent call last):  File "./test.py", line 4, in 
   
        pos = name.index("Tomz")ValueError: substring not foundname = "My name is Tom str hao bao hao"pos = name.index("Tom")print(pos)# ./test.py 11
   

count:返回统计在start和end之间str在mystr里面出现的次数

name = "My name is Tom str Tom hao bao hao"print(name.count("Tom"))# ./test.py 2

replace:把mystr中的str1替换成str2,如果count指定，则替换不超过count次

name = "My name is Tom str Tom hao bao hao"names = name.replace("Tom","tom")print(names)# ./test.py My name is tom str tom hao bao hao

5.列表

testList[1, “tom”,12..5]

列表中的元素可以是不同类型的

#!/usr/bin/python3 testList = [1,2,3,"a",12.5]for x in testList:    print(x)# ./test.py 123a12.5

列表的相关操作，列表中存放的数据是可以进行修改的，增，删，改

1）添加元素 增append,extend,insert

>>> A = ["xianwan","xianzhan","xiaohua"]>>> A['xianwan', 'xianzhan', 'xiaohua']>>> A.append("bshui")>>> A['xianwan', 'xianzhan', 'xiaohua', 'bshui']

extend : 通过extend可以将另一个集合中的元素添加到列表中

>>> a = [1,2]>>> b = [3,4]>>> a.extend(b)>>> a[1, 2, 3, 4]

insert(index,object):在指定位置index前插入元素object

>>> a.insert(2,5)>>> a[1, 2, 5, 3, 4]

2)修改元素 改

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才进行修改

>>> a[1, 2, 5, 3, 4]>>> a[1] = 6>>> a[1, 6, 5, 3, 4]

3）查找元素in,not in,index,count

查找：看指定的元素是否存在 in:存在，如果存在那么结果为true,否则为false not in:不存在，如果不存在结果为true, 否则为false index和count与字符串用法相同

>>> a[1, 6, 5, 3, 4]>>> a.index(5)2>>> a.count(5)1

4）删除元素del,pop,remove

列表的删除方法 del:根据下标进行删除 pop:删除最后一个元素 remove:根据元素的值进行删除

>>> a[1, 3, 5, 7, 9]>>> del a[0]>>> a[3, 5, 7, 9]>>> a.pop()9>>> a[3, 5, 7]>>> a.remove(5)>>> a[3, 7]

5)排序sort,reverse

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True，可改为倒序，由大到小 reverse方法是将列表逆序

>>> a[1, 4, 7, 2, 3, 9, 60, 38]>>> a.sort()>>> a[1, 2, 3, 4, 7, 9, 38, 60]>>> a.reverse()>>> a[60, 38, 9, 7, 4, 3, 2, 1]

6.元组

python的元组与列表类似，不同之处元组的元素不能修改，元组使用小括号，列表使用方括号

7.字典

字典和列表一样，能够存储多个数据

字典中找元素时，是根据名字（键 名） 字典的每个元素由2部分组成 键：值

根据键访问值：>>> info{
  'id': 100, 'name': 'xaoHua', 'sex': 'f'}>>> info["name"]'xaoHua'>>> info["sex"]'f'

若访问不存在的键会报错

>>> info["s"]Traceback (most recent call last):  File "
   
    ", line 1, in 
    
     KeyError: 's'
    
   

1）修改元素

字典中的每个元素是可以修改的

>>> info{
  'id': 100, 'name': 'xaoHua', 'sex': 'f'}>>> info["id"] = 101>>> info{
  'id': 101, 'name': 'xaoHua', 'sex': 'f'}

2）添加元素

如果在使用 变量名[“键”] = 数据 时，这个键在字典中不存在，那么会新增这个元素

>>> info{
  'id': 101, 'name': 'xaoHua', 'sex': 'f'}>>> info["tel"]=12568836457>>> info{
  'id': 101, 'name': 'xaoHua', 'tel': 12568836457, 'sex': 'f'}

3）删除元素

对字典进行删除操作 del 删除指定元素

>>> info{
  'id': 101, 'name': 'xaoHua', 'tel': 12568836457, 'sex': 'f'}>>> del info["sex"]>>> info{
  'id': 101, 'name': 'xaoHua', 'tel': 12568836457}

del删除整个字典，删除后不能访问

>>> info{
  'id': 101, 'name': 'xaoHua', 'tel': 12568836457}>>> del info>>> infoTraceback (most recent call last):  File "
   
    ", line 1, in 
    
     NameError: name 'info' is not defined
    
   

clear()只是清空整个字典

4）len() 测量字典中键值对的个数

>>> mesg{
  'id': 1, 'name': 'beng', 'year': 19}>>> len(mesg)3

5）keys 返回一个包含字典所有KEY的列表

>>> mesg{
  'id': 1, 'name': 'beng', 'year': 19}>>> mesg.keys()dict_keys(['id', 'name', 'year'])

6）values

返回一个包含字典所有value的列表

>>> mesg{
  'id': 1, 'name': 'beng', 'year': 19}>>> mesg.values()dict_values([1, 'beng', 19])

7）items

返回一个包含所有(键，值)元祖的列表

>>> mesg{
  'id': 1, 'name': 'beng', 'year': 19}>>> mesg.items()dict_items([('id', 1), ('name', 'beng'), ('year', 19)])

遍历字典的key-value

>>> mesg{
  'id': 1, 'name': 'beng', 'year': 19}>>> for key,value in mesg.items():...     print("key=%s,value=%s"%(key,value))... key=id,value=1key=name,value=bengkey=year,value=19

公共方法

8.引用

在python中，值是靠引用来传递的

我们可以用id()来判断两个变量是否为同一个值的引用，可以将id值理解为内存的地址标示

>>> a = 1>>> b = a>>> id(a)10919424>>> id(b)10919424

可变类型：值可以改变：列表list,字典dict

不可变类型：值不可以改变int,long,bool,float,str,tuple

9.函数

把具有独立功能的代码块组织成为一个小模块，这就是函数

定义函数 def 函数名(): 代码

>>> def printInfo():...     print("Life is short, I use Python")... >>> printInfo()Life is short, I use Python

函数的文档说明：help(函数名)

1）函数参数

>>> def addnum(a,b):...     return a+b... >>> a = addnum(11,22)>>> a33

定义时小括号中的参数，用来接收参数用的，叫形参

调用时小括号中的参数，用来传递给函数用的，叫实参 在函数中把结果返回给调用者，使用return 2）局部变量 局部变量：在函数内部定义的变量 不同的函数，可以定义相同的名字的局部变量，不会产生影响 作用：临时保存数据 3）全局变量 如果一个变量既能在一个函数中使用，也能在其它函数中使用就是全局变量 总结：在函数外边定义的变量叫做全局变量 全局变量能够在所有的函数中进行访问 如果在函数中修改全局变量，就需要使用global进行声明 如果全局变量的名字和局部变量的名字相同，使用的是局部变量 4）匿名函数 用lambda创建小型匿名函数，函数语法只包含一个语句

10.文件操作

1）打开文件

在python中，使用open函数可以打开一个已经存在的文件，或者创建一个新文件 open(文件名，访问模式) 访问模式 2）关闭文件 close() 3)写数据write() 4)读数据read 使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度，如果没有num,表示读取文件中所有的数据

>>> f = open("test.py","w")>>> f.write("hello")5>>> f.close()>>> f = open("test.py","r")>>> f.read()'hello'>>> f.close()

5）获取当前读写的位置

f.tell()

>>> f = open("test.py","r")>>> f.read()'hello'>>> f.tell()5

6)定位到指定位置

如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek() seek(offset,from) offset:偏移量 from:方向 ，0：表示文件开头1:表示当前位置2:表示文件末尾 7）文件的重命名 os模块中的rename()可以完成对文件的重命名操作 rename(需要修改的文件名，新的文件名)

>>> import os>>> os.rename("test.py","test1.py")>>> exit()root@bshui-virtual-machine:/home/bshui/Python# ls test1.py test1.py

8)删除文件

remove(要删除的文件名)

>>> import os>>> os.remove("test1.py")>>> exit()root@bshui-virtual-machine:/home/bshui/Python# ls9x9.py  guess.py

9）文件夹相关操作

创建文件夹：os.mkdir(“test”) 获取当前目录:os.getcwd() 改变默认目录:os.chdir(“../”) 获取目录列表:os.listdir(“./”) 删除文件Los.rmdir(“test”)

>>> import os>>> os.mkdir("test")>>> os.getcwd()'/home/bshui/Python'>>> os.chdir("./test")>>> os.getcwd()'/home/bshui/Python/test'>>> os.listdir("./")[]>>> os.chdir("../")>>> os.listdir("./")['9x9.py', 'guess.py', 'test']>>> os.rmdir("test")>>> os.listdir("./")['9x9.py', 'guess.py']

11.面向对象

面向过程：根据业务逻辑从上到下写代码

面向对象：将数据与函数绑定到一起，进行封装，减少重复代码的重写过程 类：具有相同内部状态和运动规律的实体集合 对象：一个具体事物的存在，可以直接使用 类就是创建对象的模板 1）类Class由3个部分构成 类的名称：类名 类的属性：一组数据 类的方法：允许对象进行操作的方法

#!/usr/bin/python3class Car:    def getCarInfo(self):        print("the car's whell:%d color%s"%(self.wheelNum,self.color))    def move(self):        print("the car is moving...")BMW = Car()  #创建一个对象，并用变量BMW来保存它的引用BMW.color = "black"BMW.wheelNum = 4 #给对象添加属性BMW.getCarInfo() #调用对象的方法BMW.move()# ./car.py the car's whell:4 colorblackthe car is moving...

2）init()方法

在创建对象的时候，顺便把对象的属性给设置好

#!/usr/bin/python3class Car:    def __init__(self,newWheelNum,newColor):        self.wheelNum = newWheelNum        self.color = newColor    def getCarInfo(self):        print("the car's whell:%d color%s"%(self.wheelNum,self.color))    def move(self):        print("the car is moving...")BMW = Car(4,"green")BMW.getCarInfo()BMW.move()# ./car.py the car's whell:4 colorgreenthe car is moving...

3）self的理解，可以理解为自己，当对象调用一个方法时，python解释器会把这个对象作为第一个参数传递给self,所以开发者只需要传递后面的参数即可

总结：Python没有public,private关键字区别公有和私有属性 它是以属性命名方式来区分的，如果在属性名前加2个__下划线，则表明该属性是私有属性，否则为公有属性（方法也一样） 4）del方法

创建对象后，python解释器默认调用 __init__()方法当删除一个对象时，python解释器也会默认调用 __del__()方法

5)继承

#!/usr/bin/python3class Cat(object):    def __init__(self,name,color="white"):        self.name  = name        self.color = color    def run(self):        print("%s...is running"%self.name)class Bosi(Cat):    def setNewName(self,newName):        self.name = newName    def eat(self):        print("%s---is eating"%self.name)bs = Bosi("Mick")print("bs name is :%s color is:%s"%(bs.name,bs.color))bs.eat()bs.setNewName("bscat")bs.run()# ./cat.py bs name is :Mick color is:whiteMick---is eatingbscat...is running

子类在继承的时候，在定义类时，小括号()中为父类的名字

父类的属性，方法，会被继承给子类 私有的属性，方法不会被子类继承，也不能被访问 6）多继承 python中可以多继承，父类中的方法，属性，子类会继承 子类在继承的时候，在定义类时，小括号()中为多个父类的名字用逗号隔开 7)重写父类的方法 在子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法 7）多态 定义时的类型和运行时的类型不一样

12.异常

捕获异常try…except…..

#!/usr/bin/python3try:    open("123.txt","r")except IOError:    print("no file found")# ./test.py no file found

此程序看不到错误，因为用except捕获到了IOError异常，并添加了处理方法

获取异常的信息描述

#!/usr/bin/python3try:    open("123.txt","r")except IOError as result:    print(result)# ./test.py [Errno 2] No such file or directory: '123.txt'

try…finally在程序中，如果一块代码必须要执行，无论异常是否产生都要执行，需要使用finally

13.模块

模块：工具包，里面有封装好的函数

1）import 用关键字import来引入模块 当解释器遇到import语句，如果模块在当前的搜索路径就会被导入，在调用模块的函数时，用模块名.函数名

>>> import math>>> math.sqrt(2)1.4142135623730951>>> math.sqrt(4)2.0

2）from 模块名 import函数名1,函数名2

只需要用到模块中的其中的函数，引入该函数即可 不仅可以引入函数，还可以引入一些全局变量，类等 3）from …import * 把一个模块的所有内容全都导入到当前的命名空间 from modname import * (一般不这样用)

14.模块制作

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字

# cat add.py def add(a,b):    return a+b# cat test.py #!/usr/bin/python3import addresult = add.add(11,22)print(result)# ./test.py 33

15.Python中的包

包将有联系的模块组织在一起，放到同一个文件夹下，并且在这个文件夹下创建一个名为init.py文件，这个文件夹就称为包

# ls mymath/add.py  __init__.py  __pycache__  sub.py# cat mymath/__init__.py __all__ = ["add","sub"]# cat test.py #!/usr/bin/python3from mymath import *  #导入包result = add.add(11,22)print(result)result = sub.sub(11,22)print(result)# ./test.py 33-11

16.模块的发布

1）目录结构

# ls -ltotal 8drwxr-xr-x 3 root root 4096 5月  15 09:47 mymath-rwxrwxrwx 1 root root  101 5月  15 09:57 setup.py# ls mymath/add.py  __init__.py  __pycache__  sub.py

2）编辑setup.py文件

py_modules需指明所需包含的py文件

# cat setup.py from distutils.core import setupsetup(name="bshui",version="1.0",description="test mymath module")

3）构建模块

# python3 setup.py build生成发布压缩包# python3 setup.py sdist# ls dist/bshui-1.0.tar.gz

4）安装模块

找到模块的压缩包，解压，进入目录 执行python setup.py install

# python3 setup.py installrunning installrunning buildrunning install_egg_infoRemoving /usr/local/lib/python3.5/dist-packages/bshui-1.0.egg-infoWriting /usr/local/lib/python3.5/dist-packages/bshui-1.0.egg-info

5)模块的引入

使用from import 可完成对安装的模块的使用 from 模块名 import 模块名或者*