目录

python特点

Python的基本语法格式

Python程序的构成

对象

引用

标识符

变量和简单赋值语句

常量

最基本的内置数据类型介绍

基本运算符

增强型赋值运算符

比较运算符

逻辑运算符

同一运算符

整数缓存问题

字符串

字符串的基本特点

字符串的编码

引号创建字符串

空字符串和len（）函数

转义字符

字符串拼接

字符串复制

不换行打印

从控制台读取字符串

str（）实现数字转型字符串

使用[]提取字符

replace()实现字符串替代

字符串切片slice操作 包头不包尾

split()分割和join（）合并

字符串驻留机制和字符串比较

字符串常用查找方法

去除首尾信息

大小写转换

格式排版

其他方法

字符串的格式化

填充与对齐

数字格式化

可变字符串

基本运算符

运算符优先级问题

序列

列表

常用方法

列表的创建

列表元素访问和计数

列表排序

新建列表的排序

reversed()返回迭代器

列表相关的其他内置函数汇总

多维列表

元组

元组支持

元组的创建

元组的访问和计数

zip

生成器推导式创建元组

元组

字典

字典的创建

字典元素的访问

字典元素添加，修改，删除

序列解包

用法

集合

集合创建和删除

集合相关操作

控制语句

选择结构

循环语句

break语句

continue语句

---

python特点

1.可读性强

2.简洁

3.面向对象

4.免费和开源

5.可移植性和跨平台

6.丰富的库

7.可拓展性 可嵌入到C和c++语言 胶水式语言

8.Python是动态类型语言，变量不需要显示声明类型

9.Python是强类型语言，每个对象都有数据类型，只支持该类型支持的操作

注意

1.不要在程序的行开头处增加空格，空格在python中有缩进的含义 缩进是Python语法强制的规定

2.符号都是英符号，不是中文

Python的基本语法格式

1.恰当的空格、缩进问题

<1>逻辑行首的空白符（空格/制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组.

<2>语句从新行的第一列开始。

<3>缩进风格统一

（1）每个缩进层次使用单个制表符或四个空格

（2）Python用缩进而不是{}表示程序块

注释

<1>行注释 #

<2>段注释 ‘’‘ ’‘’ 或“ ” “ ” ” “

行连接符

一行程序的长度是没有限制的，为了可读性更强，通常将一行较长的程序分为多行如下图所示

a='vhgbjhnj

gujnjnhbh

vhbhnj'

Python程序的构成

1.Python程序由模块组成。一个模块对应Python源文件，一般后缀为.py

2.模块由语句组成。运行Python程序时，按照模块中语句的顺序依次进行

3.语句时Python程序的构造单元，用于创建对象，变量赋值，调用函数，控制语句等……

对象

python中，一切皆对象，每个对象由标识（identity），类型（type），值（value）组成

1.标识通常对应对象地址，使用内置函数id（obj）可返回其标识

2.类型用于表示对象存储的数据类型，可用type（obj）获取其类型

3.值表示对象所存储 的数据信息，使用print（obj）可直接打印出值

对象的本质

一个内存块，拥有特定的值，支持特定类型的相关操作

引用

在Python中，变量也成为对象的引用。因为，变量存储的就是对象的地址，变量通过地址引用了对象。

变量位于栈内存

对象位于堆内存

标识符

基本用法用于变量、函数、类、模块等的名称

特定规则

1.区分大小写

2.第一个字符必须是字母或下划线，且有字母、下划线和数字构成

3.不能使用关键字

4.以双下划线开头和结尾的名称通常有特殊含义，尽量避免

Python标识符命名规则

模块和包头 全小写字母，尽量简单，多个单词之间用下划线隔开

函数名 全小写字母，多个单词之间用下划线隔开

类名 首字母大写，采用驼峰原则，多个单词时，每个单词第一个字母大写，其余小写

常量名 全大写字母，多个单词之间用下划线隔开

变量和简单赋值语句

1.变量的声明与赋值

变量名=表达式 变量在使用之前必须先初始化（先赋值）

2.删除变量和垃圾回收机制

可以通过del语句删除不再使用的变量 若对象无变量引用，就会被垃圾回收器回收，清空内存空间

3.链式赋值

链式赋值相当于把一个对象赋给多个变量 x=y=5

4.系列解包赋值

系列数据赋值给相对应相同个数的变量（个数必须保持一致） a，b，c = 1,2,3

常量

Python 不支持常量。 即没有语法规则限制改变一个常量的值，只能约定常量的命名规则，以及在程序的逻辑上不对常量的值作出修改 实际上可以改，只能逻辑上不做修改

最基本的内置数据类型介绍

整型（int）

浮点型（float）

布尔型（boor）

字符串型（str）

基本运算符

加 减 乘 + -

浮点数除法/7/23.5整数除法//7//23模（取余）%7%21幂238

使用divmod（）函数得到商和余数

divmod（13,3） 结果（4,1） 其中前一位是商，后一位是余数

增强型赋值运算符 运算符例句等价+=a+=2a=a+2-=a-=2a=a-2=a=2a=a2/=a/=2a=a/2//=a//=2a=a//2=a=2a=a2%=a%=2a=a%2

符号与符号之间不能加空格

比较运算符 符号含义返回值==等于（a==b）返回 True!=不等于（a!=b）返回 True>大于（a>b）返回 True<小于（a=大于或等于（a>=b）返回 True<=小于或等于（a<=b）返回 True

逻辑运算符 运算符例句含义or（或）x or yx为True，返回True，否则返回yand（与）x and yx为True，返回y，否则返回falsenot（非）x not yx为True，返回false，否则返回true

同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址

is 判断两个标识符是否引用同一个对象，及比较对象的地址

not is 判断两个标识符是否引用不同对象

is 与 == 的区别

==用于判断引用变量引用对象的值是否相等，默认调用对象的"——eq——()"方法

整数缓存问题

python仅仅对较小的整数对象进行缓存（范围[-5,256]),而非所有的整数对象，需要注意的是，这仅仅是在命令行中执行，而在pycharm或者保存为文件执行，结果是不一样的，这是因为解释器做了部分优化。（范围[-5,无穷大]）对于缓存下来的数，若再用变量对其进行引用，其地址等一切都相等

is运算符比==效率高，在变量和None进行比较时，应用is

字符串

字符串的基本特点

本质字符序列

Python的字符串是不可变的，无法对其做任何修改

but 可将字符串的一部分复制到新创建的字符串，达到看起来修改的效果

Python不支持单字符类型，单字符也是作为一个字符串使用

字符串的编码

Python 3 直接支持Unicode编码

在Unicode编码中，一个汉字只算一个字符

引号创建字符串

可通过单引号或双引号创建字符串 a='abc' b="abc"

好处 可以创建本身就包含引号的字符串，无需转义字符

连续三个单引号或三个上引号可创建多行字符串

空字符串和len（）函数

Python允许空字符串的存在，不包含任何字符且长度为0

len（）用于计算字符串含有多少字符

转义字符 续行符反斜杠符单引号双引号退格换行横向制表符回车\'"bntr

字符串拼接

1.可用多个+将多个字符串拼接起来 'aa'+'bb'=>'aabb' 每运算一个+，都要新创建一个字符串

（1）若+两边都是字符串，则拼接

（1）若+两边都是字符串，则拼接

（2）若+两边都是数字，则加法运算

（3）若+两边类型不同，则抛出异常

2.可将多个字符串直接放到一起实现拼接（中间用空格隔开）'aa' 'bb'=>'aabb'

字符串复制

使用可实现字符串复制

a="abc"3 #等价于a="abcabcabc"

不换行打印

在调用print时，会自动打印一个换行符，若不想换行时，可通过参数end="任意字符串"，实现末尾添加任何内容

print("sxt",end="#")	#其输出为	sxt#
print("sxt",end="")		#默认一个空格

从控制台读取字符串

使用input（）从控制台读取键盘输入的内容

myname=input("请输入名字")		#应用格式，“”中内容可省略
print(myname)

str（）实现数字转型字符串

str（）可帮助将其他数据类型转换为字符串

例str（5.20）=> ‘5.20’ str(3.14e2) => '314.0' str(True) =>'True'

当调用print函数时，解释器自动调用了str（）将非字符串的对象转化为字符串

使用[]提取字符

字符串的本质就是字符序列，可通过在字符串后面添加[]，在[]里面指定偏移量，可提取该位置的单个字符

正向搜索

最左侧第一个字符，偏移量是0，第二是1，依此类推直到len（str）-1为止

反向搜索

最右侧第一个字符，偏移量是-1，以此类推，直到-len（str）为止

例 a='abcdef' a[0]='a' a[-1]='f'

replace()实现字符串替代

字符串是不可改变的，我们通过[]可以获取字符串指定位置的字符，不能改变字符串，而当需要改变某些字符时，只能通过创建新字符串来实现

a="abcdefg"
a=a.replace('c',"高")	#创建一个新字符串，将原本a中的c改为‘高’并赋给a

字符串切片slice操作 包头不包尾

切片slice操作可快速提取字符串，标准格式[起始偏移量start终止偏移量end步长step]

操作实例/含义结果[:]提取整个字符串"abcdef"[:]"abcdef"[start:]从start索引开始到结尾"abcdef"[2:]"cdef"[:end]从头开始直到end-1"ancdef"[:2]"an"[start​end : step]从start提取到end-1，步长是step"abcdef"[1:5:2]"bd""abcdef"[-3:]倒数三个"def""abcdefghijk"[-8:-3]倒数第8到倒数第3"defgh""abc"[::-1]倒输出"cba"

split()分割和join（）合并

split（）可基于指定分隔符将字符串分隔成多个子字符串（存储到列表中）若不指定分隔符，则默认使用空白字符（换行符，空格，制表符）

a="to be or not to be"
print(a.split())	#输出 ['to','be','or','not','to','be']
print(a.split('be'))	#输出	['to ',' or not to ','']

join()的作用与split（）的作用恰好相反，用于将一系列子字符串连接起来

a=['sxt','sxt99']
print(''.join(a))	#输出:"sxtsxt99"

join（）函数在拼接字符串之前会计算字符串的长度，然后逐一拷贝，只新建一次对象，其比+拼接符更好

字符串驻留机制和字符串比较

字符串驻留仅保存一份相同且不可变字符串的方法。不同的值被存放在字符串驻留池中。Python支持其机制，对于符合标识符规则的字符串（仅包含下划线，字母和数字）会启动字符串驻留机制

字符串比较和同一性

可用==，!=对字符串进行比较，是否含有相同的字符

用is，not is 判断两个对象是否同一个对象，比较的是地址

成员操作符

in，not in 关键字，判断两个字符（子字符串）是否存在于字符串中

字符串常用查找方法 方法含义len(a)字符串长度a.startsith('xx')是否以指定字符串开头a.endsith("xx")是否以指定字符串结尾a.find('x')第一次出现指定字符串的位置a.rfind('x')一次出现指定字符串的位置a.count('x')出现指定字符串的次数a.isalnum()所有字符是否全为字符或数字

去除首尾信息

可通过strip（）去除字符串首尾指定信息，通过lstrip（）除去字符串左边指定信息，rstrip（）除去字符串右边指定信息

a="sxt"
print(a.strip(''))	#输出"sxt"
print(a.lstrip(''))	#输出"sxt"
print(a.rstrip(''))	#输出"sxt"

大小写转换 ​

a="abT ab"

​ 函数含义结果a.capitalize()产生新的字符串，首字母大写"AbT ab"a.title()产生新的字符串，每个单词的首字母大写"AbT Ab"a.upper()产生新的字符串，所有字母转换成大写"ABT AB"a.loer()产生新的字符串，所有字符转换成小写"abt ab"a.sapcase()产生新的字符串，所有大小写互换"abT ab"

格式排版

center（）,ljust(),rjust()用于字符串实现排版

a="sxt"
print(a.center(10,''))	#输出"sxt"
print(a.ljust(10,"#"))	#输出"sxt#######"
print(a.center(10))	#输出"   sxt " ,未指定填充字符，默认空格

其他方法

函数含义isalnum()是否为字母或数字isalpha()检测字符串是否只由字母组成（含汉字）isdigit()检测字符串是否由数字组成isspace()检测是否为空白符isupper()是否为大写字母isloer()是否为小写字母

字符串的格式化

format函数可以接受不限个参数，位置可以不按顺序

a="名字是{0},年龄是{1}"
print(a.format("小李",18))	#输出名字是小李，年龄是18
print(a.format("小张",20))	#输出名字是小张，年龄是20
b="名字是{name},年龄是{age}"
print(b.format(age=28,name="小敏"))	#输出名字是小敏，年龄是28

填充与对齐

^ < > 分别是居中，左对齐，右对齐；后面带宽度，号后面带填充字符，只能带一个，不带默认空格

print("{:>8}".format("234"))	#输出"234" {:>8}表示字符串长度为8，右对齐，用填充

数字格式化

浮点数通过f，整数通过d进行需要的格式化

数据格式化结果含义3.14159{:.2f}3.14保留两位小数3.14159{:+.2f}3.14带符号保留两位小数2.71828{:.0f}3不带小数5{:0>2d}05数字补0（填充左边，宽度为2）1000000{:,}1,000,000以逗号分隔的数字形式0.25{:.2%}25.00%百分比格式1000000000{:.2e}1.00e+09指数记法

可变字符串

Python中，字符串属于不可变对象，不支持原地修改，可使用ioStringIO对象或array模块

import io
s="hello,sxt"
sio=io:StringIO(s)
print(sio)	#输出
print(sio.getvalue())	#输出"hello,sxt"
sio.seek(7)
sio.rite("g")
print(sio.getvalue())	#输出"hello,gxt"

基本运算符

and or not 与 或 非

| ^ & 按位 或 异或 与

<< >> 位移 a>>2 =>a=a4

1.比较运算符可以连用，并且含义和日常使用完成一致

a=3
if 3

2.位运算

bin（）可以将数字转换成二进制

3.加法运算

列表，元组等合并

[10,20,30]+[10,20,30]==[10,20,30,10,20,30]

4.乘法运算

[10,20,30]2==[10,20,30,10,20,30]

5.复合赋值运算符

"<<" 左移赋值 a<<=2 a=a<<2

">>" 右移赋值 a>>=2 a=a>>2

与c和java不一样，Python不支持自增（++）自减（--）操作

运算符优先级问题

1.乘除优先加减

2.位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

复杂的表达式一定要使用小括号组织

序列

序列是一种数据存储方式，用来存储一系列的数据

Python中常用的序列结构字符串，列表，元组，字典。集合

列表

列表用于存储任意数目，任意类型的数据集合

列表是内置可变序列，其中元素可以各不相同，是不同类型

常用方法 方法作用含义list.append(x)增加元素将元素x加入至列表尾部list.extend(alist)增加元素将列表alist所有元素加到列表list尾部list.insert(index ,x)增加元素在列表指定位置index处插入元素xlist.remove(x)删除元素从列表list中删除出现的元素xlist.pop([index])删除元素删除并返回列表list指定为止index处的元素，默认一个list.clear()删除所有元素删除列表中所有元素，并不是删除列表list.index()访问元素返回第一个x的索引位置，若不存在，抛出异常list.count()计数返回指定元素x在列表中出现的次数len(list)列表长度返回列表所含元素个数list.reverse()翻转列表所有元素远点翻转list.sort()排序所有元素原地排序list.copy()浅拷贝返回列表对象的浅拷贝

Python的列表大小可变，根据需要随时增加或缩小

列表的创建

1.基本语法[]创建

a=[10,20,30]

b=[] #创建一个空的列表

2.list（）创建

使用list（）可将任何可迭代的数据转换为列表对象

a=list() #创建一个空的列表

a=list(range(10)) #a=[1,2,3,4,5,6,7,8,9]

3.range()创建整数列表

语法格式 range（[start,]end[,step])

start参数可选，表示起始数字，默认是0

end参数必选，表示结尾数字

step参数可选，表示步长，默认是1

Python 3 中range（）返回的是一个range对象，而不是列表，需通过list（）方法将其转换成列表对象

4.推导式生成列表

例 a=[x2 for x in range(5)] #循环创造多个元素 输出a=[0,2,4,6,8]

列表元素访问和计数

与字符串一般可通过索引直接访问元素

index（）获得指的是元素在列表中出现的索引

语法 index（value，[start,[end]]）其中start，end指定了搜索范围

成员资格判断

用in，not in关键字判断是否存在包含关系

列表同样使用字符串的切片slice

列表的遍历

for obj in list obj:

print(obj)

列表排序

修改原列表，不建新列表的排序

例 a=[20,10,30,40]

a.sort() #默认是升序排列

print(a） #输出[10,20,30,40]

a.sort(reverse=True) #降序排列

print（a） #输出[40,30,20,10]

import random

random.shuffle(a) #打乱顺序

print（a) #输出[20,40,10,30]

新建列表的排序

通过内置函数sorted（）进行排序，这个方法返回新列表，不对原列表做修改

例 a=[20,10,40,30]

b=sorted(a) #升序排列

print(b) #输出[10,20,30,40]

print(a) #输出[20,10,40,30]

reversed()返回迭代器

内置函数reversed（）也支持进行逆序排列，与列表对象reverse（）方法不同的是，内置函数reversed（）不对原列表做任何修改，只是返回一个逆序排序的迭代器对象

例 a=[20,10,40,30]

c=reversed(a)

print(c) #输出

print(list(c)) #输出[10,20,30,40]

print(list(c)) #输出[] reversed()一次，只能使用一次

列表相关的其他内置函数汇总

max和min

用于返回列表中最大，最小值

sum

对数值型列表的所有元素进行求和操作，对非数值型列表运算报错

多维列表

二维列表可存储二维，表格的数据

例

a = [

["高小一"，18,30000]，

["高小二"，19,20000]

]

元组

属于不可变序列，不能修改元组中的元素，无增加元素，修改元素，删除元素的相关方法

元组支持

1.索引访问

2.切片操作

3.连接操作

4.成员关系操作

5.比较运算操作

6.计数元组长度len（），最大值max，最小值min，求和sum

元组的创建

1.通过（）创建元组

例

a=(10,20,30) 或者 a=10,20,30

若元组中只含一个元素时，其后必须加逗号，否则解释器会将其认为整数

2.通过tuple（）创建元组

a=tuple()	#创建一个空元组
a=tuple("abc")
a=tuple(range(3))
a=tuple([2,3,4])

tuple（）可以接收列表字符串，其他序列类型，迭代器等生成元组

list（）可以接收元组，字符串，其他类型，迭代器生成列表

元组的访问和计数

1.远足的元素不能修改

2.元组的元素访问和列表一样，只不过返回的是元组对象

3.列表关于排序的方法list.sorted()是修改列表对象，元组没有该方法，若要对元组排序，只能使用内置函数sorted(tuple obj)，并生成新的列表对象

zip

zip（列表1，列表2……）将多个列表对应位置的元素组合成为元组，并返回这个zip对象

例

a = [1,2,3]

b=[4,5,6]

c=[7,8,9]

d=zip(a,b,c)

print(list(d)) #输出[(1,2,3),(4,5,6),(7,8,9)]

生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表，也不是元组，而是一个生成器对象

s=[x2 for x in range(5)]
print(s)	#输出  at ox000000002BDEB48>
print(s.__next__())	#输出0
print(tuple(s))	#输出(0,2,4,6,8)
print(list(s))	#输出[]	只能访问一次，第二次就为空了，需要再生成一次才能输出

元组

1.元组的核心特点不可变序列

2.元组的访问和处理速度比列表快

3.与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用

字典

字典是“键值对”的无序可变序列，字典中的每个原先都是一个“键值对”，包含“键对象”和“值对象”。可通过“键对象”实现快速获取，删除。更新对应的“值对象”

“键”是任意的不可变数据。比如整型，浮点型，字符串，元组。列表，字典，集合这些可变对象，不能作为“键”，并且“键”不可重复

“值”可以是任意的数据，并且可重复

字典的创建

1.通过{}，duct（）来创建字典对象

a={"name":"gaiqi","age":18}
b=dict(name="gaoqi",age=18)
a=dict([("name","gaoqi"),("age",18)])

2.通过zip（）创建字典对象

a=["name","age"]
b=["gaoqi",18]
c=dict(zip(a,b))	#前者为键，后者为值
print(c)	#输出{"name":"gaoqi","age":18}

3.通过fromkeys创建值为空的字典

a=dict.fromkeys(["name","age"])
print(a)	#输出{'name':None,'age':None}

字典元素的访问

1.通过[键]获得“值”，若键不存在，则抛出异常

2.通过get（）方法获得“值”。

优点指定键不存在时，返回None，也可以设定当指定键不存在时，默认返回的对象

3.列出所有的键值对

a.item()

4.列出所有的键和值

a.keys() a.values()

5.len()键值对的个数

6.检测一个键是否在字典中

in ，not in

字典元素添加，修改，删除

1.给字典新增“键值对”，若“键”已存在，则覆盖旧的键值对，若不存在，则新增键值对

2.使用update（）将新字典中所有键值对全部添加到旧的字典对象上，若key有重复，则直接覆盖

3.字典中元素的删除，可以使用del（）方法，或者clear（）删除所有键值对，pop删除指定键值对，并返回对应的“值对象”

4.popitem随机删除和返回该键值对。字典是“无序可变序列”，没有第一个元素，一个元素的概念，popitem弹出随机的项，因为字典并没有“的元素”或者其他有关顺序的概念，若想一个接一个地移除项，这个方法非常有效

序列解包

序列解包可用于元组，列表，字典。序列解包可方便对多个变量赋值

序列解包用于字典时，默认是对“键”进行操作，若需对“键值对”进行操作，则需使用item（），对值进行操作，则需使用values（）

s={"name":"gaoqi","age":18}
name,age=s
print(name)	#输出name
name,age=s.item()
print(name)	#输出("name","gaoqi")
name,age=s.values()
print(age)	#输出 18

用法

1.键必须可散列

（1）数字，字符串，元组都是可散列的

（2）自定义对象需支持以下三点

<1>支持hash（）函数

<2>支持通过——eq——（）方法检测相等性

<3>若a==b为真，则hash（a）==hash（b）也为真

2.字典在内存中开销巨大，典型的空间换时间

3.键查询速度很快

4.往字典里面添加新键可能导致扩容，导致散列表中键的次序变化，，不要在遍历字典的进行字典的修改

集合

集合是无序可变，元素不能重复的序列，实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，是不能重复且唯一的

集合创建和删除

1.使用{}创建集合对象，并使用add（）方法添加元素

a={1,3,6}
a.add(9)
print(a)	#输出{9,1,3,6}

2.使用set（）将列表，元组等可迭代对象转化成集合，若有重复数据，则值保留一个

3.remove（）删除指定元素，clear（）清空整个集合

a.remove(x) a,clear(x)

集合相关操作

a|b == a.union(b) #并集

a&b == a.intersection(b) #交集

a-b == a.difference(b) #差集 只显示a中有b中无的

控制语句

选择结构

1.单分支选择结构语句

语法形式 if 条件表达式（逻辑，关系，算术等表达式）

语句 （多条语句，缩进必须一致）

2.双分支选择语句

语法形式 if 条件表达式

语句

else

语句

三元条件运算符

语法格式 条件为真时的语句 if （条件表达式） else 条件为假时的语句

3.多分支选择语句

语法形式 if 条件表达式语句

elif 条件表达式语句

……

[else: 语句]

计算机行业，描述语法格式时，使用括号[]表示可选，非必选

4.条件表达式详解

在选择，循环结构中，条件表达式的值为false的情况如下

false，0, 0.0， 空值， None， 空序列对象， 空range对象， 空迭代对象

条件表达式中，不能有赋值操作符“=”

循环语句

1.hile 循环

语法格式 hile 条件表达式

循环体语句

2.for循环和可迭代对象遍历

for循环语法格式 for 变量 in 可迭代对象

循环体语句

可迭代对象（Python）

1.序列。包含字符串，列表，元组

2.字典

3.迭代器对象

4.生成器对象

5.range对象

break语句

结束本层循环

continue语句

结束本次循环，直接进入下一次