一、Python介绍

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言

Python 的设计具有很强的可读性

Python 是一种解释型语言

Python 是交互式语言

Python 是面向对象语言

Python 是初学者的语言

二、发展历程

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

三、Python的特点

易于学习

易于阅读

易于维护

一个广泛的标准库

互动模式

可移植

可扩展

数据库：Python提供所有主要的商业数据库的接口。

GUI编程

可嵌入

四、Pycharm及python安装

五、创建python file

六、Python变量和数据类型

1、变量的定义

num1=100#num1        就是一个变量，就好一个小菜篮子num2=87#num2也是一个变量result=num1+num2     把num1和num2这两个"菜篮子"中的数据进行累加，然后放到 result变量中

说明：程序就是用来处理数据的，而变量就是用来存储数据的

2、Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

注意：在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别

可以使用type(变量的名字)，来查看变量的类型

3、标识符

（1）标识符的概念：

开发人员在程序中自定义的一些符号和名称

标识符是自己定义的,如变量名 、函数名等

（2）标识符的命名规则

  标识符只能由字母、下划线“_”、数字组成。

. 标识符不能以数字开头。

. 标识符不能使用关键字

. 标识符对大小写敏感。

（建议:标识符命名应“见名知意”）

（3）python中的关键字

'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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'

4、注释

单行注释:/* */

多行注释:'''

5、标识符的命名方法

小驼峰式命名法：函数名 addName

大驼峰式命名法：类名 AddName

6、Python中print语句

（1）print() 方法用于打印输出，最常见的一个函数。

参数:

objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。

sep -- 用来间隔多个对象，默认值是一个空格。

end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

file -- 要写入的文件对象。

（2）格式化输出

方式一:使用百分号（%）字符串格式化

print("my name is %s, and my age is %d" %(name,age)

方式二：使用format字符串格式化

位置参数

print("my name is{}, and my age is{}".format(age,name))

（3）关键字参数

print("my name is {name}, and my age is {age}".format(age=18,name="jack"))

注释:位置参数("{0}".format())，关键字参数("{关键字}".format())

7、设置换行符号

print(a,b,c,d,e,sep=";",end="\n");

8、Python中input语句

input() 用来获取控制台的输入。

语法：

input([prompt])

9、Python中变量

a = 123 # a是整数

print (a)

a = 'imooc'  # a变为字符串

print (a)

b=11; #b是整数

d=11.1;#d是浮点数

print(b*d)

10、Python条件循环和判断

（1）语句

Python 编程中 if 语句用于控制程序的执行，基本形式为：

if 判断条件：

    执行语句……

else：

    执行语句……

（2）If else 语句

age = 12

if age>18:

    print("年龄大于18")

else:

    print("年龄小于等于18")

age=20;

if age>18:

    print("年龄大于18")

if not age <=18:

    print("年龄大于18")

注意：Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的 print 语句就构成一个代码块。如果 if 语句判断为 True，就会执行这个代码块。

缩进请严格按照Python的习惯写法：4个空格，一个Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

（3） If else else 多层嵌套方式

age=10;

if age >= 18:

    print ('adult')

else:

    if age >= 6:

        print ('teenager')

    else:

        if age >= 3:

            print ('kid')

        else:

            print ('baby')

标准格式

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

当判断条件为多个值时，可以使用以下形式：

if 判断条件1:

    执行语句1……

elif 判断条件2:

    执行语句2……

elif 判断条件3:

    执行语句3……

else:

执行语句4……

（4）For循环：重复执行语句

forn inrange(1,20):print(n)arr=[100,90,86,80,77]forindex in arr:print(index)

注意:  b这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体（就是缩进的代码块）

（5）While 循环

Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：

while 判断条件：

    执行语句……

练习:求100以内的和

sum = 0

i = 0

while i < 100:

    sum += i

    i += 1

print(sum)

（6）Break中断循环

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

（7）Continue

Python continue 语句跳出本次循环，而break跳出整个循环。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

continue语句用在while和for循环中。

（8）嵌套循环

Python 语言允许在一个循环体里面嵌入另一个循环

for x in ['A', 'B', 'C']:

    for y in ['1', '2', '3']:

        print (x + y)

（9）Python字符串操作

字符串转义

a='learn  "python" from teacher liang';b='bob said \"I\'m ok\"';print(a)print(b);

\n 表示换行

\t 表示一个制表符

\ 表示 \ 字符本身

<1>字符串截取操作(左闭右开)

a="hello world";

print(a[0:2])  #he 截取字符串 从第0到第2个 包含头不包含尾

print(a[1]) #e 某个索引的字符

<2>字符串拼接

b="hello";c="world"d=b+c;print(d)#hello world 字符串拼接

<3>包含不包含,使用in和not in判断是否包含

<4>常用字符串的操作api

a="hello world"

print(a.upper())#HELLO WORLD 变成大写

b=a.startswith("hello");#true  是以什么进行开头

c=a.endswith("world");#true 以什么进行结尾

d=a.replace("h","hhhhh");#hhhhhello world 替换字符

print(d);

11、Python中List和Tuple类型

序列是Python中最基本的数据结构。

序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

a= ['physics', 'chemistry', 1997, 2000]

b = [1, 2, 3, 4, 5 ]

c = ["a", "b", "c", "d"]

（1）定义集合

a=["aaa",123,"bbb",True];#定义集合

（2）获取某个索引的元素

print(a[1]);#123 获取索引值为1处的元素

（3）倒序获取元素

print(a[-1],a[-2],a[-3],a[-4]);#True bbb 123 aaa 倒数第一个，倒数第二个，倒数第三个

12、添加元素

（1）追加

a.append("哈哈哈");print(a);#['aaa',123,'bbb',True,'哈哈哈']

（2）插入

a.insert(1,"82岁韩美林);a.insert(2,"PGone")print(a);#['aaa','李小璐','PGone',123,'bbb',True,'哈哈哈']

13、删除元素

a.pop(2);a.pop(1);print(a);#['aaa',123,'bbb',True,'哈哈哈']删除某索引值的元素

14、替换元素

a[2]="贾乃亮";a[-1]="吼吼吼"print(a);#['aaa',123,'贾乃亮',True,'吼吼吼']替换指定位置元素

15、定义元组(Tuple)[ˈtjup(ə)l]

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

t = ('Adam', 'Lisa', 'Bart')

16、Dict介绍--字典类型 dictionary

（1）字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

（2）Dict特点

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

列表中找某个元素时，是根据下标进行的；字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'age'、'sex'）

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

由于dict是按 key 查找，所以，在一个dict中，key不能重复。

dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样：

dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

（3）元素获取

print(info["name"])print(info.get("name"))##print(info.get("xx"))如果元素没有会报错误

（4）字典的增删改操作

<1>修改元素

字典中每个元素都是可修改的，只要通过key找到，既可以修改Demo

info["name"]="李四"

<2>添加元素

想要添加元素，只需要指定key 指定 value就可以

info["address"]="北京"

<3>删除元素

对字典进行删除操作，有以下两种方式：

# del info[] 指定要删除的元素

delinfo["name"]

# clear 清空元素

info.clear()

（5） 字典内置函数&方法

len(dict):计算字典元素个数，即键的总数。 >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(dict)3

str(dict):输出字典，以可打印的字符串表示。    >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(dict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

type(variable):返回输入的变量类型，如果变量是字典就返回字典类型。 >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(dict)<class 'dict'>

(6)字典的常见操作

<1>keys() 获取字典的所有key 列表

print(info.keys())

<2>values 获取字典的所有values 列表

print(info.values())

<3>items 返回一个包含所有元组(键，值)的列表

print(info.items())

(7)字典的遍历

<1>遍历key

for key in info.keys():

    print(key)

<2>遍历value

forvalueininfo.values():print(value)

<3>遍历items

for item in info.items():

  print(item)

<4>遍历key value

forkey,valueininfo.items():print(key,value)

16、Python中函数

（1）什么是函数

如果在开发的时候，需要某块代码多次，但是为了提高便携的效率以及代码的重用，所以把具有独立功能的代码块组织成一个小的模块，这就是函数。

（2）函数定义和调用

<1>定义函数

定义函数的格式如下：

def函数名():代码

定义一个函数，能够完成打印信息的功能

defprintInfo():

print'------------------------------------

'print'        人生苦短，我用Python'

<2>调用函数

通过函数名() 即可完成调用

# 定义完函数后，函数是不会自动执行的，需要调用它才可以      printInfo()

（3）函数的好处

减少代码的冗余，减少维护量，功能的封装，降低学习成本，提高开发速度

（4） 函数参数

定义带有参数的函数:

defprintSum(a,b):print(a+b)

调用带有参数的函数

printSum(10,20)

形式参数和实际参数

定义时小括号中的参数，用来接受参数用的,称为“形参”

调用时小括号中的参数，用来传递给函数用的，称为”实际参数”

（5）缺省参数

默认有参数值的函数

defstudent(name,age,sex="男"):print(name,age,sex)student("格日仓",18)student("格日仓",20,"女")

（6）可变参数(一 元组类型)

defgetSum(*args):print(args)sum=0foriinargs:sum+=ireturnsumprint(getSum(1,2,3,4))

(7)可变参数(二 字典类型)

dic={'a':90,'b':80,'c':70,'d':100}

defkv(**kwargs):

print(kwargs)

kv(a=90,b=80,c=70,d=100)

17、函数返回值

所谓返回值，就是程序中函数完成一件事后，最后给调用者的结果。

18、函数类型

无参数，无返回值的函数

无参数，有返回值的函数

有参数，无返回值的函数

有参数，有返回值的函数

19、函数的嵌套调用

案例:在函数A中调用函数B，然后调用函数。

分析调用顺序。

defadd():print("这是add1")print("加法运算的逻辑")defadd2():print("想实现加法的运算")add()print("计算出一个结果")add2()

20、局部变量

局部变量，就是在函数内部定义的变量

不同的函数，可以定义相同的名字的局部变量，各用个的不会影响

局部变量作用:为了临时保存数据需要在函数中定义变量来存储。

21、全局变量

如果一个变量，既能在一个函数中使用，又能在其他函数中使用，这样的变量就是全局变量。

在函数外边定义的变量叫做全局变量

全局变量能够在所有的函数中进行访问

如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的

注意：#全局变量：在函数外定义的变量

#局部变量：在函数内部定义的变量

#全局变量与局部变量，就近原则

22、递归函数

如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

（1）循环完成

求n的阶乘

defgetMultipy(n):

i=1

result=1

whilei<=n:

result=result*i       

 i+=1

return  result

print(getMultipy(10))

（2）函数调用函数自身

求n的阶乘

def  getMultipy(n):

if    n>=1:

result=n*getMultipy(n-1)else:

result=1

return    result

print(getMultipy(3))

23、Python中模块和包

在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块。

（1）导入模块import 语句

import    module1[,module2[,...moduleN]

在调用 math 模块中的函数时，必须这样引用：

#模块名.函数名     import    math

（2）from…import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 math 的 pi 函数，使用如下语句：

from    math    importpi

print(pi)

（3）.导入自定义模块

在test1中定义求和方法

defsum(a,b):returna+b

test中直接导入方法

from    test2    import    sum

print(sum(1,2))

24、文件操作

（1）什么是文件

使用文件的目的：就是把一些文件存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力

（2）打开、关闭文件

python中打开文件，可以使用open函数，可以打开一个已经存在的文件，或者创建一个新的文件。

open(文件名，访问模式)

f = open('test.txt', 'w')

关闭这个文件

f.close()

（3）文件访问模式

文件打开分为两种：文本模式（r/w/a），二进制模式（rb/wb/ab）

（4）文件的读写

<1>写数据(write) - write()方法

write()方法不会在字符串的结尾添加换行符('\n')：

<2>读数据(read)

使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据

f = open('test3.txt','r')

print(f.read())

读数据（readlines）读取每一行

<3>

Python写入内容

file=open("test.txt","r+")

content=file.read(2)

print(content)

content=file.read()

print(content)

file.close()

<4>如果open是打开一个文件，那么可以不用写打开的模式，即只写 open('test.txt')

如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的

（5）File对象的属性

一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。

以下是和file对象相关的所有属性的列表：

file.closed    返回true如果文件已被关闭，否则返回false。

file.mode    返回被打开文件的访问模式。

file.name    返回文件的名称。

file.softspace    如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

（6）

25、文件的重命名、删除

有些时候，需要对文件进行重命名、删除等一些操作，python的os模块中都有这么功能

(1)文件重命名

os模块中的rename()可以完成对文件的重命名操作

rename(需要修改的文件名, 新的文件名)

importosos.rename("毕业论文.txt","毕业论文-最终版.txt")

(2)删除文件

os模块中的remove()可以完成对文件的删除操作

remove(待删除的文件名)import osos.remove("毕业论文.txt")

(3)创建文件夹，删除文件夹

Python里的目录：

所有文件都包含在各个不同的目录下，不过Python也能轻松处理。

os模块有许多方法能帮你创建，删除和更改目录。

<1>mkdir()方法

可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。

<2>rmdir()方法

rmdir()方法删除目录，目录名称以参数传递。

注意：在删除这个目录之前，它的所有内容应该先被清除。

Import os

os.mkdir("aaa")

os.rmdir("test")

print(os.getcwd()) 获取当前目录

(4)文件拷贝

(1)打开现有一个文件1，读取文件当中的内容

test = open("E:\\ceshi.txt","r")

read = test.readlines()

(2)新建一个文件，写入文件1当中的内容

test2=open("test2.txt","w")forx in read:test2.write(x)test.close()test2.close()

(3)读取新文件内容

test3 = open("test2.txt",'r')

print(test3 .read())

26、ython面向对象编程

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

面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程

面向对象编程的2个非常重要的概念：类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类

类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象

类与对象的关系：类就是创建对象的模板

(1)类(Class) 由3个部分构成：

类的名称:类名

类的属性:一组数据

类的方法:允许对进行操作的方法 (行为)

对象 = 属性 + 方法

静态 + 动态

(2)创建对象

通过上一节课程，定义了一个Car类；就好比有车一个张图纸，那么接下来就应该把图纸交给生成工人们去生成了

python中，可以根据已经定义的类去创建出一个个对象

创建对象的格式为:

对象名 = 类名()

(3) Python中创建实例属性

虽然可以通过Person类创建出xiaoming、xiaohong等实例，但是这些实例看上除了地址不同外，没有什么其他不同。在现实世界中，区分xiaoming、xiaohong要依靠他们各自的名字、性别、生日等属性。

（4）在定义 Person 类时，可以为Person类添加一个特殊的init()方法，当创建实例时，init()方法被自动调用

init()方法，在创建一个对象时默认被调用，不需要手动调用init(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么init(self)中出了self作为第一个形参外还需要2个形参，例如init(self,x,y)

init(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去

（5） Python中访问限制

我们可以给一个实例绑定很多属性，如果有些属性不希望被外部访问到怎么办？

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问

但是，如果一个属性以"xxx"的形式定义，那它又可以被外部访问了，以"xxx"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"xxx"定义。

（6）python中定义实例方法

一个实例的私有属性就是以__开头的属性，无法被外部访问，那这些属性定义有什么用？

虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。

实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的

（7） python中创建类属性

类是模板，而实例则是根据类创建的对象。

绑定在一个实例上的属性不会影响其他实例，

但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！

也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

（8）python中定义类方法

和属性类似，方法也分实例方法和类方法。

在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。

27、Python中继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

（1）为什么要继承

新类不必从头编写，代码的重用

新类从现有类继承，就自动拥有了现有类的所有功能

新类只需要编写现有类缺少的新功能

（2）继承特点以及单继承

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

父类的属性、方法，会被继承给子类

（3）多继承

（4）多继承同名方法调用

先继承哪个，就调用哪个的方法

（5）方法的重写及调用父类方法

（6）类属性和对象属性

类属性就是类(类对象)所拥有的属性。它被类和所有对象所拥有。对于共有类属性，在类外可以通过类对象和实例对象访问。

（7）python中多态（了解）

（8）python中多重继承（了解）

28、Python中异常

（1）什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

#演示各种异常情况

#第一个异常，数学异常

# ZeroDivisionError: division by zero <<ArithmeticError ctrl+/快速注释

# i=1/0

#第二个异常，类型转换错误

# TypeError: must be str, not int

# age=int(input("请输入年龄"))

# print("年龄是"+age)

#第三个异常:文件异常

# FileNotFoundError: [Errno 2] No such file or directory: 'aa.txt'

# file=open("aa.txt","r")

# file.write("哈哈")

# file.close()

#第四个异常 未定义异常

# NameError: name 'num' is not defined

# print(num)#编译错误

（2）异常处理

捕捉异常可以使用try/except语句。

（3）Try-finally 语句

（4）主动触发异常

我们可以使用raise语句自己触发异常