python基础语法

基础概述

python文件类型

python常用的文件类型有3种。

文件后缀	描述
.py	源代码文件，由python程序解释，不需要编译
.pyc	字节代码文件，由源代码文件编译而成
.pyo	优化编译后的程序，二进制文件，适用于嵌入式系统

编码规范

1. 运行方式

（1）交互运行
在命令行输入python或者打开python自带的IDLE。例如：

C:\Users\dangdang>python
Python 3.7.0 (default, Jun 28 2018, 08:04:48) [MSC v.1912 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

（2） 以脚本方式运行
保存为*.py类型，然后运行。

2. python标识符

python标识符是用来标识一个变量、函数、类、模块或其他对象的名称。

标识符的命名规则：
（1） 由字母下划线和数字组成，必须以下划线或字母开头；
（2）变量名区分大小写；
（3）不能使用python保留字。

除了命令规则外，还有一些特殊的命令样式：

• 前后有下划线的变量名通常为系统变量，如_name_；
• 以一个下划线开头的变量不能被from…import语句从模块导入；
• 以两个下划线开头的变量是类的本地变量，如__abc。

3. 缩进

• python使用缩进来表示代码块，不需要使用大括号；
• 同一代码块中的语句必须包含相同的缩进空格数。

4. 注释

• 单行注释，使用#进行单行注释；
• 多行注释，使用多个#或者’’’ ‘’’；

5. 多行语句

语句太长可以使用反斜杠(\)来实现多行。

在同一行使用多条语句，语句间使用分号分割。

数据类型

python3有6个标准的数据类型：Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Sets(集合)、Dictionary(字典)。

Number(数字）

1. 整型
   可以用二进制、十进制、八进制（以0开头）、十六进制（以0x开头）表示，有正负之分。
2. 浮点型
   由整数部分和小数部分组成。还可以用科学计数法表示（2.5e2=2.5×102=250）。
3. 布尔型
   只有两个值，True和False。
4. 复数
   复数由实部+虚部构成，使用complex函数来创建复数，complex(实部,虚部)。

String(字符串）

python字符串有多种表示方式。

1. 单引号和双引号
   都可以用来表示字符串，可以嵌套着使用。

>>> 'hello'
'hello'
>>> "hello"
'hello'
>>> "hello ' world"
"hello ' world"

2. 三引号
   用来表示多行字符串。还可以用作多行注释。

>>> ''' hello
... mike'''
' hello\nmike'

3. 转义字符(\)
   特殊字符需要使用转义字符。
4. 带r或R前缀的字符串
   不会解析字符串中的转义字符

>>> r'\n'
'\\n'
>>> R'\t'
'\\t'

字符串的特殊用法：

• 可以使用+运算符将字符串连接在一起
• 可以使用*运算符重复字符串
• 两种索引方式，从左到右，从0开始，从右到左，从-1开始
• 可以对字符串进行切片，格式为：变量[开始索引:结束索引]，截取范围为前闭后开，索引可以省略。

>>> print('str'+'ing','my'*3)
string mymymy
>>> word='hello'
>>> word[0]
'h'
>>> word[4]
'o'
>>> word[-1]
'o'
>>> word[-4]
'e'
>>> word[:]
'hello'
>>> word[1:3]
'el'

变量及赋值

变量是计算机内存中的一块区域，存储规定范围内的值，其值在程序中可以改变。python是动态数据类型语言，定义变量时不需要声明其数据类型。python的数据类型是在程序运行时自动决定的。

python赋值方式：

1. 简单赋值
   左边变量，右边为值。

x=2

2. 序列赋值

• 左侧为元组，列表，存在多个变量名，右侧为序列的值。
• 右侧为字符串时，左侧为序列时，就会将字符串分解，若变量和字符串数量不等，会报错。
• 使用*表示剩余的列表对象。

>>> a,b=1,2  #使用省略圆括号的元组赋值
>>> a,b
(1, 2)
>>> (a,b)=10,20 　#使用元组赋值
>>> a,b
(10, 20)
>>> [a,b]=[30,'abc'] #使用列表赋值
>>> a,b
(30, 'abc')
>>> (x,y,z)='abc'
>>> x,y,z
('a', 'b', 'c')
>>>
>>> x,*y='abcd'
>>> x,y
('a', ['b', 'c', 'd'])
>>> *x,y='abcd'
>>> x,y
(['a', 'b', 'c'], 'd')

3. 多目标赋值

>>> a=b=c=10
>>>a,b,c
(10,10,10)

4. 增强赋值

>>> a=5
>>> a+=10　　　　　　　 #等价于a=a+10
>>> a
15

可以使用type方法用来测试变量的类型：

>>> type(a)
<class 'int'>
>>> a=True
>>> type(a)
<class 'bool'>

运算符

算术运算符

运算符	说明
+	加
-	减
*	乘
/	除
//	取整
%	取余
**	幂运算

赋值运算符

运算符	说明
=	直接
+=	加法赋值
-=	减法赋值
* =	乘法赋值
/=	除法赋值
//=	整除赋值
**=	幂赋值

逻辑运算符

运算符	说明
and	逻辑与
or	逻辑或
not	逻辑非

关系运算符

运算符	说明
==	等于
!=	不等于
<>	不等于
>	大于
>=	大于等于
<	小于
<=	小于等于

字符串运算符

运算符	说明
+	字符串连接
*	重复字符串
[]	通过索引获取字符
[:]	截取字符串
in	包含字符串返回True
not in	不包含字符串返回True
r/R	原始字符串
%	格式化字符串，一般和print一起使用

常见的格式符有：

格式符	说明
%c	转换为字符
%r	优先使用repr()函数进行字符串转换
%s	优先使用str()函数进行字符串转换
%d/%i	转成有符号十进制数
%u	转成无符号十进制数
%o	转成无符号八进制数
%x/%X	转成无符号十六进制数
%e/%E	转成科学计数法
%f/%F	转成浮点数
%g/%G	%e/%E，%f/%F的简写
%%	输出%

位运算符

运算符	说明
&	按位与
|	按位或
^	按位异或
~	按位取反
<<	按位左移
>>	按位右移

运算符优先级

优先级如下：

运算符	说明
**	幂运算
~	按位取反
-	负号
*、%、/、//	乘除
+、-	加减
<< 、>>	位移
&	按位与
^	按位异或
|	按位或
<、<=、>、>=、==、!=	关系比较
not、and、or	逻辑运算符

数据结构

列表

列表是一个没有固定长度的，用来表示任意类型对象的位置相关的有序集合。

1. 列表的基本操作

(1) 创建列表
用方括号将逗号分隔的不同的数据项括起来。

list=[1,2,3,'ab']

(2) 访问列表
列表中每个元素都有一个索引，从0开始。

>>> list[1]
2

(3) 列表元素赋值
分为整体赋值和指定位置赋值。

list=[1,2,3,'ab']
list[3]=4

(4) 删除列表元素
使用del语句实现删除，只能删除已存在范围的数据。

del x[1]

(5) 分片赋值
截取某一段范围的列表元素，前开后闭。

>>> list=[1,2,3,'a','b','c']
>>> list[1:3]
[2, 3]

2. 列表的常用方法

>>> list=[10,8,7,5,4]
>>> list
[10, 8, 7, 5, 4]
>>> list.append(1)  #在列表末尾追加新对象
>>> list.append(4)
>>> list
[10, 8, 7, 5, 4, 1, 4]
>>> list.count(4)  # 统计某元素在列表中出现的次数
2
>>> list1=['a','b','c']
>>> list.extend(list1)  # 在列表末尾另一个列表
>>> list
[10, 8, 7, 5, 4, 1, 4, 'a', 'b', 'c']
>>> list.insert(1,12)#在指定位置插入列表
>>> list
[10, 12, 8, 7, 5, 4, 1, 4, 'a', 'b', 'c']
>>> list1.reverse() #反转列表中的元素
>>> list1 
['c', 'b', 'a']
>>> list1.remove('a') #移除列表中某个值的第一个匹配项
>>> list1
['c', 'b']
>>> list1.sort()  #对列表进行排序
>>> list1
['b', 'c']
>>> len(list1) #返回列表的长度
2
>>> max(list1) #返回列表中最大值
'c'
>>> min(list1) #返回列表中最小值
'b'
>>> list.index(4) #返回某个值第一次出现的位置
1
>>> list.pop() #移除列表的最后一个元素，返回该元素的值
'c'
>>> list.pop(1) #移除指定位置的元素，返回该元素的值
4

元组

元组和列表类似，用圆括号括起来。不同的是元组的内容一旦定义不能修改。

>>> t1=(1)
>>> type(t1)
<class 'int'>
>>> t2=(1,) #定义单个元组时需要加逗号
>>> type(t2)
<class 'tuple'>
>>> t3=(1,2,4,5) 
>>> t3[:] #可以通过索引切片访问
(1, 2, 4, 5)
>>> t3[1:3]
(2, 4)

若想对元组进行排序添加等操作，需要将元组转换为列表。

字典

字典是一种映射的数据结构，字典中每个元素都有键和值两个属性，键值对以冒号隔开。字典的基本操作和其他序列相似。
相关方法：

>>> te1=[('name','mike'),('age',12)]
>>> te=dict(te1)  #通过映射或序列建立字典
>>> te
{'name': 'mike', 'age': 12}
>>> te['name']
'mike'
>>> t1=te.clear() #清除字典中的项，没有返回值
>>> print(t1)
None
>>> te
{}
>>> te={'x':1,'y':2,'z':3}
>>> te.pop('y') #删除指定的字典元素
2
>>> te
{'x': 1, 'z': 3}
>>> te={'x':1,'y':2,'z':3}
>>> print(te['a'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'a'
>>> print(te.get('a')) #获取指定键对应的值，若不存在该键，不会报错
None
>>> te.keys()  #以列表的形式返回字典的键值
dict_keys(['x', 'y', 'z'])
>>> te.values() #以列表的形式返回字典的值
dict_values([1, 2, 3])
>>> te1={'name':'mike','age':23}
>>> te3={'name':'mike','sex':'man'}
>>> te1.update(te3) #将两个字典合并
>>> te1
{'name': 'mike', 'age': 22, 'sex': 'man'}

集合

集合由一组无序元素组成，集合中没有重复值。
常用的操作：

>>> t1=set([1,2,4,5,1]) #创建集合，参数只有一个
>>> t1
{1, 2, 4, 5}
>>> t1.add(7) #在集合中添加元素
>>> t1
{1, 2, 4, 5, 7}
>>> t2=set(('a','b'))
>>> t2
{'a', 'b'}
>>> t1.update(t2) #将另一个集合加入其中
>>> t1
{1, 2, 4, 5, 7, 'a', 'b'}
>>> t1.remove(2) #移除指定元素
>>> t1
{1, 4, 5, 7, 'a', 'b'}
>>> t1.clear() #清空集合
>>> t1
set()

有关集合的特殊运算符：

>>> set([1,2])==set((1,2))  #比较两个集合是否相等
True
>>> set([1,2])!=set((1,3)) #比较两个集合是否相等
True
>>> set([1,2])<set((1,2)) #前面的集合是否为后面集合的真子集
False
>>> set([1,])<set((1,2))
True
>>> set([1,2])<=set((1,2))  #前面的集合是否为后面集合的子集
True
>>> set([1,2])>=set((1,2))  #前面的集合是否为后面集合的超集
True
>>> set([1,2,3])>set((1,2))  #前面的集合是否为后面集合的真超集
True
>>> set([1,2,3])|set((1,2))  #前面的集合和后面集合的并集
{1, 2, 3}
>>> set([1,2,3])|set((1,2,4)) 
{1, 2, 3, 4}
>>> set([1,2,3])&set((1,2,4))  #前面的集合和后面集合的交集
{1, 2}
>>> set([1,2,3])-set((1,2,4))  #前面的集合和后面集合的差集
{3}

程序控制结构

结构化程序设计有 3 种基本控制结构：顺序结构、选择结构和循环结构。

选择结构

if语句的语法有以下几种：

if (表达式):
语句块
-------------
if (表达式):
语句块1
else:
语句块2
--------------
if (表达式1) :
语句块1
elif (表达式2):
语句块2
…
elif (表达式n):
语句块n
else:
语句块n+1

循环结构

在Python程序设计语言中主要有两种循环结构：while循环和for循环。

1. while循环

while (表达式):
<语句块>

2. for循环

for 变量　in　集合:
语句块

3. continue和break

continue 语句的作用是立即结束本次循环，重新开始下一轮循环，与 continue 语句不同，break 语句的作用是跳出整个循环，其后的代码都不会执行。

表达式

运算表达式

根据运算符的不同分为算术运算符、赋值运算符·、比较运算符、逻辑运算符(not,and,or)、成员运算符（in,not in,is,is not）、位运算符。

>>> 5/2
2.5
>>> 5//2
2
>>> 5>2
True
>>> 5>2 and 4<3
False
>>> 1 in (1,2)
True
>>> 2<<3
16
>>> a=16
>>> b=a
>>> a is b
True
>>> c=16
>>> a is c
True
>>> a=[1,2]
>>> a=b
>>> a is b
True
>>> c=[1,2]
>>> c is b
False
>>> id(c)
2339245971912
>>> id(a)
140736146960608
>>> id(b)
140736146960608

三元表达式

python的三元表达式没有标准格式，可以使用如下几种格式：

1. 使用if语句

>>> a=10
>>> b=5
>>> c=7
>>> a=b if b>c else c
>>> a
7

2. 使用and,or
   先判断and左边的表达式，若左边为False直接执行or的右边的表达式，若为True，则执行and右边的表达式，若and右边表达式为False，则结果为or右边的表达式。

>>> a=10
>>> b=5
>>> c=7
>>> a=b<c and b or c
>>> a
5

and ,or的问题在于，对于逻辑运算来说0本身就是False，若对0进行比较，会存在如下问题：

>>> 0>-1 and 0 or -1
-1
>>> 0<-1 and 0 or -1
-1

解决方式，可以通过添加列表避免不能和0进行比较：

>>> a=(b>c and [b] or [c])[0]
>>> a
7

列表解析表达式

列表中是for循环，还可以添加一些if条件和特定表达式，相当于map或者filter函数。还可以多层循环。

>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [i**2 for i in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [i**2 for i in range(10) if i%2==0]
[0, 4, 16, 36, 64]
>>> [(i**2,j) for i in range(5) if i%2==0 for j in range(5)]
[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4), (16, 0), (16, 1), (16, 2), (16, 3), (16, 4)]

生成器表达式

有__iter__()为可迭代对象，生成器表达式的优势在于使用多少数据就计算多少数据，节省了空间。

>>> a=(i**2 for i in range(5))
>>> a
<generator object <genexpr> at 0x00000220A61955E8>
>>> for i in a:
...     print(i)
...
0
1
4
9
16
>>> dir(a)
['__class__', '__del__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__name__', '__ne__', '__new__', '__next__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'close', 'gi_code', 'gi_frame', 'gi_running', 'gi_yieldfrom', 'send', 'throw']

Lambda表达式

lamdba只有一行语句，没有return语句，没有函数名。相当于匿名函数。

>>> c=lambda x:x*2
>>> c(2)
4
>>> c(5)
10
>>> c=lambda *x:[i for i in x if i%2==0]
>>> c(1)
[]
>>> c(1,2,3,4,5)
[2, 4]