Python基础语法个人学习笔记

个人笔记，才疏学浅，恐有错漏，错漏之处还望指出。

1.安装工具

1. 下载Python ，再下载pycharm

2.Python基础语法

变量的使用及介绍

1.定义变量
变量名 = 值
例子：

 下面展示一些 `内联代码片`。

name = 'Python'
print(name)
print(type(name))
//type 检测数据类型

// An highlighted block
name = 'Python'
print(name)
print(type(name))

 **2.变量类型：**

1. 数值： int、float
2. bool（布尔型）：False、True
3. String
4. list (列表)
5. tuple（元组）不可变
6. set（集合）
7. dict（字典）
   下面展示一些 内联代码片。

// A code block
c = [10,20,30]  #list
print(type(c))
d = (10,20,30)  #tuple
print(type(d))
e = {10,20,30}  #set
print(type(e))
d = {'name':'Tom','age' : '18'}   #dict
print(type(d))

// An highlighted block
c = [10,20,30]  #list
print(type(c))
d = (10,20,30)  #tuple
print(type(d))
e = {
     10,20,30}  #set
print(type(e))
d = {
     'name':'Tom','age' : '18'}   #dict
print(type(d))

格式的输出：

1.格式化符号：
%s、%d、%f、%c、%u、%o、%X、%x、%e、%E、%g、%G
2.格式化输出：
下面展示一些 内联代码片。

// A code block
age = 18
name = 'Tom'
weight = 12.34432
print('我的名字%s'% name)
print('我的age%03d'% age)
print('我的weight%.3f'% weight)
print('我的weight%f,我的name%s,我的age%d' % (weight, name,age))
print('我的weight%f,我的name%s,我的明年的年纪%d' % (weight, name,age+1))
print('我的weight%s,我的name%s,我的明年的年纪%s' % (weight, name,age+1))

```javascript
// An highlighted block
age = 18
name = 'Tom'
weight = 12.34432
print('我的名字%s'% name)
print('我的age%03d'% age)
print('我的weight%.3f'% weight)
print('我的weight%f,我的name%s,我的age%d' % (weight, name,age))
print('我的weight%f,我的name%s,我的明年的年纪%d' % (weight, name,age+1))
print('我的weight%s,我的name%s,我的明年的年纪%s' % (weight, name,age+1))

3.格式化字符串输出：
语法： f’{表达式}'
下面展示一些 内联代码片。

// A code block
age = 18
name = 'Tom'
weight = 12.34432
print(f'我的name{name}，我的age{age}，我的体重{weight}')

// An highlighted block
age = 18
name = 'Tom'
weight = 12.34432
print(f'我的name：{name}，我的age：{age}，我的体重：{weight}')

转义字符：

1. \n 换行
2. \t 制表（四个空格键的距离）
   下面展示一些 内联代码片。

// A code block
print("hollow\nworld")
print("hollow\tworld")

// An highlighted block
print("hollow\nworld")
print("hollow\tworld")

结束字符：

1. 结束字符：
   语句 print(’ ‘,end=’ ')
   下面展示一些 内联代码片。

// A code block
print('hollow world',end='\n''hollow world')
print('\thollow world',end='\t''hollow world')

// An highlighted block
print('hollow world',end='\n''hollow world')
print('\thollow world',end='\t''hollow world')

Print字符：

1. print本身带有换行符号，其写法应为print(’ ‘,end=’ \n’)
2. 单纯的print(’ ')默认带\n。
3. print(’ ',end = ’ '）不带换行。

下面展示一些 内联代码片。

// A code block
print('hollow world')
print('hollow world',end='\n')
print('hollow world',end='不换行')
print('hollow world')

// An highlighted block
print('hollow world')
print('hollow world',end='\n')
print('hollow world',end='不换行')
print('hollow world')

输入：

1. 语法：input()，只有输入信息后才会执行下一步。
2. input的输入的东西是以字符串的形式处理。

下面展示一些 内联代码片。

// A code block
c=input('提示信息')
print(c)
print(type(c))

// An highlighted block
c=input('提示信息')
print(c)
print(type(c))

数据转换：

1. int(x,base) 将x转换为一个整数，x – 字符串或数字，base – 进制数，默认十进制。x为字符串时没有base
2. float(x) 将x转换为一个浮点数
3. str(x) 将x转换为一个字符串
4. eval(str) 函数用来执行一个字符串表达式，并返回表达式的值，将字符串转换为原本的类型。
5. tuple(x) 将序列x转换为一个元组
6. list(x)** 将序列x转换为一个列表
7. 补充:
   x=[[1]]3
   print(x)
   y=[[1],[1],[1]]
   x[0][0]=5
   print(x)
   y[0][0]=6
   print(y)
   目前怀疑是复制的问题
   以上比较重要
8. complex(real,imag) 创建一个复数，real为实数，imag为虚数
9. repr(x) 将x转换为表达式字符串
10. char(x) 将整数x转换威威Unicode字符
11. ord(x) 将字符x转换为ASCII整数值
12. hex(x) 将整数x转换为十六进制字符串

下面展示一些 内联代码片。

// A code block
num = '123'
print(num)
print(type(num),end='\n')

d=211
print(type(d),end='\n')

e=float(d)
print(type(e),end='\n')

c=int(num)
print(type(c),end='\n')

print(int(num,16))
print(type(c),end='\n')

print(str(d))
print(type(d),end='\n')

print(eval( '2' + '3' ),end='\n')
print(type(eval('2'+'3')),end='\n')

list1=[10,23,45]
print(type(tuple(list1)),end='\n')
print(type(list(list1)),end='\n')

x = 7
print(eval( '3 * x' ))
print(type(eval( '3 * x' )),end='\n')

tuple1='(10,20,309)'
list2 ='[10,20,309]'
print(type(eval(tuple1)),end='\n')
print(type(eval(list2)),end='\n')

// An highlighted block
num = '123'
print(num)
print(type(num),end='\n')

d=211
print(type(d),end='\n')

e=float(d)
print(type(e),end='\n')

c=int(num)
print(type(c),end='\n')

print(int(num,16))
print(type(c),end='\n')

print(str(d))
print(type(d),end='\n')

print(eval( '2' + '3' ),end='\n')
print(type(eval('2'+'3')),end='\n')

list1=[10,23,45]
print(type(tuple(list1)),end='\n')
print(type(list(list1)),end='\n')

x = 7
print(eval( '3 * x' ))
print(type(eval( '3 * x' )),end='\n')

tuple1='(10,20,309)'
list2 ='[10,20,309]'
print(type(eval(tuple1)),end='\n')
print(type(eval(list2)),end='\n')

运算符：

1. 算术运算符：低级：+(加或者合并) - 中间：*(乘或者复制) / // % 高级： * * ( ) （）指数（//）整除**

运算符	描述	实例 a=10，b=20
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//24 >>> -9//2-5

 	下面展示一些 `内联代码片`。

// A code block
print(2+3,end='=2+3\n')
print(3-2,end='=3-2\n')
print(2-3,end='=2-3\n')
print(2/3,end='=2/3\n')
print(3/2,end='=3/2\n')
print(2*3,end='=2*3\n')
print(2**3,end='2**3\n')
print(3%2,end='=3%2\n')
print(3-2+(2+3),end='=3-2+(2+3)\n')

// An highlighted block
print(2+3,end='=2+3\n')
print(3-2,end='=3-2\n')
print(2-3,end='=2-3\n')
print(2/3,end='=2/3\n')
print(3/2,end='=3/2\n')
print(2*3,end='=2*3\n')
print(2**3,end='2**3\n')
print(3%2,end='=3%2\n')
print(3-2+(2+3),end='=3-2+(2+3)\n');

2. 赋值运算符：

	**=**
	下面展示一些 `内联代码片`。

// A code block
number = 1
print(number)
number,float,str = 12,12.32,'12.34'
print(f'{number}',f'{float}',f'{str}')

// An highlighted block
number = 1
print(number)
number,float,str = 12,12.32,'12.34'
print(f'{number}',f'{float}',f'{str}')

3. 逻辑运算符：**and or not **

运算符逻辑表达式	描述	实例（a 为 10, b为 20）
x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20
x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10
not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

下面展示一些 内联代码片。

// A code block
number = 1
print(number==1 and number!=1)
print(number==1 or  number!=1)
print( not number)

// An highlighted block
number = 1
print(number==1 and number!=1)
print(number==1 or  number!=1)
print( not number)

5. 复合赋值运算符：**+= - = = /= %= * = //=

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

6. 比较运算符： ** != == < > >= <= **

运算符	描述	实例a为10，变量b为20
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

7. 三目运算符：条件成立表达式 if 条件 else 条件不成立表达式

8. in not in

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False>x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not	in如果在指定的序列中没有找到值返回 True，否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True 。

条件语句：

1. if条件语句
   语句：
   **if 条件：
   代码块1
   代码块2
   … **
   或者
   if 条件：
   代码块1
   代码块2
   else：
   代码块1
   代码块2
   …
   或者
   if 条件：
   代码块1
   elif 条件2：
   代码块2
   …
   …
   else 条件3：
   代码块3
   以此类推，直至成立。
   下面展示一些 内联代码片。

// A code block
if True:
    print('if')
    print('java')
if False:
    print("if")
print('停止')

// An highlighted block
if True:
    print('if')
    print('java')
if False:
    print("if")
print('停止')

循环语句：

While和for

1. While：

	 **while 条件 ：
	 	代码块1
	 	代码块2
	 	.....**

下面展示一些 内联代码片。

// A code block
i=1
sum = 0
while i<=100:
    if i%2==0 :
        sum+=i
    i+=1
print(sum)

// An highlighted block
i=1
sum = 0
while i<=100:
    if i%2==0 :
        sum+=i
    i+=1
print(sum)

3. for：

	**for 临时变量 in  序列：
	  	代码块
	  	代码块
	  	**
	  	**或者 i for i in range(数据)就是i= for i in range(数据)** 列表可用。
	  	**或者 i for i in range(数据) if 条件:/while 条件：就是i= for i in range(数据) if 条件:/while 条件：** 列表可用。
**或者 (i,j) for i in range(数据) for j in range(数据)**  列表可用。
	**或者 dict1 = {i：i**2 for i in range(数据)}就是dict1 = {i：i的平方,i+步长：i+步长的平方，...}**

下面展示一些 内联代码片。

// A code block
str = '1233243'
list =[12,2354,565]
tuple =(12,323,34)
set= {13,34,54}
dict= {'abc': '123','war':'354'}
for i in str:
    print(i,end=' ')
print(str)
for i in list:
    print(i,end=' ')
print(str)
for i in tuple:
    print(i,end=' ')
print(list)
for i in set:
    print(i,end=' ')
print(set)
for i in dict:
    print(i,end=' ')
print(dict)

// An highlighted block
str = '1233243'
list =[12,2354,565]
tuple =(12,323,34)
set= {
     13,34,54}
dict= {
     'abc': '123','war':'354'}
for i in str:
    print(i,end=' ')
print(str)
for i in list:
    print(i,end=' ')
print(str)
for i in tuple:
    print(i,end=' ')
print(list)
for i in set:
    print(i,end=' ')
print(set)
for i in dict:
    print(i,end=' ')
print(dict)

else

1. while else
   语句:
   while 条件：
   循环时的代码块
   else ：
   循环正常结束时的代码块

2. for else
   语句;
   for 临时变量 in 序列：
   代码块
   else :
   循环正常结束时的代码块

下面展示一些 内联代码片。

// A code block
str = '1233243'
for i in str:
    if i=='3':
        break
    print(i)
else: print('结束')

for i in str:
    if i=='3':
        continue
    print(i)
else: print('结束')

// An highlighted block
str = '1233243'
for i in str:
    if i=='3':
        break
    print(i)
else: print('结束')

for i in str:
    if i=='3':
        continue
    print(i)
else: print('结束')

continue和break：

1. continue：
2. break：

字符串：

切片：

3. 序列[开始的位置：结束位置的下标：步长]
   下面展示一些 内联代码片。

// A code block
str = '1233243dfffe'
print(str[2:14:2],end=' ')

// An highlighted block
str = '1233243dfffe'
print(str[2:14:2])

操作方法：

1. **find()：**检测在字符串是否包含该字串，没有返回-1.
   语法：
   序列.find( 字串，开始位置下标，结束位置下标）
   下面展示一些 内联代码片。

// A code block
str = '1233243dfffe'
print(str.find('3',0,8));

// An highlighted block
str = '1233243dfffe'
print(str.find('3',0,8))

1. **index()**检测在字符串是否存在该字符，不存在要报错。
   语法：
   字符串序列.index(字串，开始位置下标，结束位置下标)

2. conut返回该字符在序列里的出现的次数。
   语法：
   字符串序列.count(字串，开始位置下标，结束位置下标)

3. replace替换
   语法：
   字符串序列.replace(旧字串，新字串，替换次数）

4. **split（）**字符出现的次数+1
   语法：
   字符串序列.split( 分割字符，num） 返回num的次数+1

5. **join()**合并
   语法：
   字符串序列/字串.join(多字符\字串组成的序列）
   下面展示一些 内联代码片。

// A code block
str = ['12','232','43']
str1='...'.join(str)
print(str1)

// An highlighted block
str = ['12','232','43']
str1='...'.join(str)
print(str1)

1. **cpitaize()**将字符串首个字符大写，其他全小写。

2. **title()**将字符串每个单词首字母大写。

3. **lower()**将大写转换为小写。

4. **upper()**将小写转为大写。

5. **lstrip()**删除字符操左侧空白字符。**trip()**删除俩侧空白。rstrip() 删除右侧

6. **ljust()左对齐rjust()**右对齐
   语法：
   ljust(长度，填充符） 不足位数用填充符补充。

7. startswith(）：
   语法：
   字符串序列.startswith(字串，开始的位置，结束的位置) 检查是否以该字串开始 endswith() 是结尾用的

8. isalpha() 至少有一个字符并且每个字符都是字母

9. isdigit() 只包含数字

10. **isspace()**是否都是空格

11. **isalnum()**是否包含数字或字母或数字字母组合

列表：

	语法：
	**[数据1，数据2，数据3，.....]**可以存储多个数据，且可以不同数据类型，具有顺序即下标，具有可变性。

增加：

1. len() 列表的长度，
   语法：列表.len()
   列表的操作方法与字符串一致。

2. in 和not in
   语法：
   t in 列表 判断 t 这个数据是否存在列表中。
   t not in 列表 判断 t 这个数据是否不存在列表中。

3. append():
   语法：
   列表.append(单个数据) 结尾追加数据，序列数据是以整体添加

4. extend():
   语法：
   列表.extend(数据) 结尾追加数据，序列数据拆开添加。

下面展示一些 内联代码片。

// A code block
list = [19,23,34]
list.append([12,32,434])
print(list)
list.extend([12,23,34])
print(list)

// An highlighted block
list = [19,23,34]
list.append([12,32,434])
print(list)
list.extend([12,23,34])
print(list)

1. insert()
   语法：
   **列表.insert(位置下标，数据)**指定位置添加

删除：

2. del
   语法：
   del 目标删除

3. pop()
   语法：
   **列表序列.pop(下标)**删除改下表数据，并返回该数据

4. remove()
   语法：
   **列表.remove(数据)**移除列表中第一个匹配项。

5. clear()
   语法：
   **列表.clear()**清空列表
   下面展示一些 内联代码片。

// A code block
list = [19,23,34,45,6534,43,567,534]
list.pop(2)
print(list)
del list[2]
print(list)
list.remove(19)
print(list)
list.clear()
print(list)

// An highlighted block
list = [19,23,34,45,6534,43,567,534]
list.pop(2)
print(list)
del list[2]
print(list)
list.remove(19)
print(list)
list.clear()
print(list)

修改：

1. **reverse()**逆置
   语法：
   **列表.reserve()**颠倒顺序

2. sort()
   语法：
   **列表.sort(key = None，reverse= True/False)**排序，reverse排序规则，True 降序，False 升序（默认）,key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

3. 修改数据;
   语法：
   列表的下表数据 = 值

下面展示一些 内联代码片。

// A code block
list = [19,23,34,45,6534,43,567,534]
list[0] = 34
print(list)
list.sort()
print(list)
list.reverse()
print(list)

// An highlighted block
list = [19,23,34,45,6534,43,567,534]
list[0] = 34
print(list)
list.sort()
print(list)
list.reverse()
print(list)

复制：

1. copy()
   语法：
   列表1 = 列表.copy()

列表嵌套：

2. 格式：list=[[34,45,54],[12,232,],[…],…]相当于二维数组
   下面展示一些 内联代码片。

// A code block
list = [[19,23,34],[45,6534,43,],567,534]
print(list[1][2])
print(list[1])

// An highlighted block
list = [[19,23,34],[45,6534,43,],567,534]
print(list[1][2])
print(list[1])

元组：

1. 可以存储多个数据，数据不可以修改。
2. 只有单个数据是也必须跟上“ ，”。
3. 只支持查找数据。
4. 当元组里有列表，列表数据可以修改。

元组的操作方法：

1. **index()**检测在字符串是否存在该字符，不存在要报错。
   语法：
   元组.index(字串，开始位置下标，结束位置下标)

2. conut返回该字符在序列里的出现的次数。
   语法：
   元组.count(字串，开始位置下标，结束位置下标)

3. len() 列表的长度，
   语法：元组.len()

字典：

4. 以键值对的形式保存，不存在下标。
5. 字典顺序与数据顺序无关，找到键即可找到数据。
6. 形式：dict = {键1：值1，键：值，… }
7. 可变类型，不支持+

增加：

	**语法：字典[key] = 值** key存在就修改值，不存在就添加键值对。

删除：

1. del：
   语法：del（字典）或 del 字典[key]
2. clear：
   与列表一样。

改：

1. 语法：字典[key] = 值

查找：

1. 按key值查找

2. get：
   语法：字典.get(key，参数1)key不存在，则返回参数1.

3. keys：
   语法:dict.keys( ) 返回全部的key，是一个可迭代的对象即可用for循环。

4. values：
   语法：dict.values( ) 返回全部的value，是一个可迭代的对象

5. items:
   语法：dict.items()返回全部的键值对的一个可迭代的元组对象

下面展示一些 内联代码片。

// A code block
dict = {'e123':123,'e456':456,'e678':678}
print(dict['e123'])
dict['e1234'] = 1234
print(dict['e1234'])
dict['e1234'] = 12345
print(dict['e1234'])
del dict['e1234']
print(dict)
print(dict.get('e123','找到'))
dict.clear();
print(dict)
dict = {'e123':123,'e456':456,'e678':678}
del (dict)
print(dict)
dict = {'e123':123,'e456':456,'e678':678}
print(dict.keys())
print(dict.values())
print(dict.items())

// An highlighted block
dict = {
     'e123':123,'e456':456,'e678':678}
print(dict['e123'])
dict['e1234'] = 1234
print(dict['e1234'])
dict['e1234'] = 12345
print(dict['e1234'])
del dict['e1234']
print(dict)
print(dict.get('e123','找到'))
dict.clear();
print(dict)
dict = {
     'e123':123,'e456':456,'e678':678}
del (dict)
print(dict)
dict = {
     'e123':123,'e456':456,'e678':678}
print(dict.keys())
print(dict.values())
print(dict.items())

集合：

1. 创建集合用{}或set()，空集合只能用set() ，{ }用来创建空字典。
2. 集合没有顺序，不支持下标。
3. 数据不能重复，具有去重功能。
4. 是可变类型。

增加：

5. add()
   语法：集合.add(单个数据),
6. update()
   语法：集合.update(序列)

删除：

7. remove
   语法:集合.remove(指定数据) 数据不存在会报错。
8. discard
   语法:集合.discard(指定数据) 数据不存在不会报错。
9. ** pop**
   语法: 集合.pop() 随机删除数据，并返回这个数据

查找：

in 和not in
语法：
t in 集合 判断 t 这个数据是否存在列表中。
t not in 集合 判断 t 这个数据是否不存在列表中。

已有的函数：

普通函数

10. len() 计算容器中的元素
11. del或者del() 删除
12. max()或min() 元素里的最大值最小值
13. range(start,end,step) 遍历数字序列，可以使用内置range()函数。可创建一个整数列表。
14. enumerate(可遍历的对象，starts) 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中,starts 是开始值。

高阶函数

16. abs() 求绝对值
17. around( x [, n] ) 参数x – 数值表达式。n – 数值表达式，表示从小数点位数。尾数为5时取最近的偶数。
18. map(function, iterable, …) function – 函数名，iterable – 一个或多个序列，第一个参数 function 以参数序列中的每一个元素调用 function 函数，python3中map()返回的是一个object，需要list可以直接用list(……)来强制返回一个列表。
19. reduce（function, iterable, …） 必须要有两个参数，用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
20. filter（function, iterable, …） 过滤不符合条件的序列的元素，返回一个filter（object）对象。需要list可以直接用list(……)来强制返回一个列表。

自定义函数:

15. 语法:

	**def 函数名(参数)：
		代码1
		代码2
		.......**

16. 调用函数

1. 先定义后调用。
2. 函数名(参数)。
3. return 返回值后面的语句不执行。
4. return 返回多个函数值 return 值1，值2，…或者数据序列.默认返回是一个元组。

17. 调用函数的文档说明

4. 语法：
   **help(函数名)**查看函数的说明文档。
5. 自定义文档：
   def 函数名(参数)：
   " " " 说明文档的位置 " " "或者
   " " "
   内容
   " " "
   打多行注释的提示文字·
   代码
   …

变量作用域:

局部变量：

6. 定义在函数体内部的变量，即在函数体内部生效。
7. 作用：临时保存数据。

全局变量:

1. 函数体内外都能生效。
2. 在函数中修改全局变量，先global声明变量为全局变量，再重新赋值。global是关键字。

参数:

位置参数:

3. 调用函数时根据函数定义的参数位置来传参。
4. 传参和定义的参数的个数及顺序必须一致。

关键字参数:

5. 通过“键=值“的形式加以指定，不存在顺序关系
6. 有位置参数时要在关键字参数前面。

缺省参数：

1. 默认参数，用于定义函数，给某些参数提前赋值，没传值时使用默认值。
2. 所有的位置参数必须在默认参数前面。

不定长参数:

**包裹位置传值：**不确定个数用的

1. 语法：
   def 函数名( * 参数)：
   代码 所有的传参都会被参数接纳，参数会合并为一个元组。

**包裹关键字传值：**不确定个数用

2. 语法：
   def 函数名( * * 参数)：
   代码 所有的传参都会被参数接纳，参数会合并为一个字典。

拆包和变换变量的值:

拆包:

元组拆包:

3. 语法：
   tuple= 数据1，数据2，…
   值1，值2，…=tuple值1，值2就是壹壹相应return的值

字典拆包:

4. 语法：
   dict = {key 1：value1，key2：value2，…}
   值1，值2，…= dict值1，值2就是壹壹对应的dict里的key。

交换变量的值:

5. 第三个变量：
   a =10， b = 23

6. 方法二：
   语法:a,b = 10,32
   a,b = b,a

引用:

7. **Id()**可以判断两个变量是否是同一个值的引用。值只靠引用来传递的。

*8. 不可变类型在修改数据时引用地址。
8. 可变类型数据在修改数据时是修改源数据。*错误

9. 用引地址也可以当实参。

可变与不可变:

10. 不可变：整型、浮点型、字符串、元组。不可变类型在修改数据时是会存储在其他地址。

11. 可变：列表、字典、集合。可变类型在修改数据时其地址不变。

递归：（后续补)

lambda表达式(匿名函数):有知识欠缺，后期增加

12. 语法：
    lambda 参数1，参数2，… : 表达式只有一个表达式的值，只有一句代码。返回lambda的值时是一个地址object，参数可以提前赋值。

13. 使用时的语法：
    变量名 = lambda 参数1，参数2，… ：表达式
    调用: 变量名(参数1，参数2，… )

14. 可变参数：lambda ( * 参数): 表达式 参照参数知识点

15. lambda ( * * 参数): 表达试 参照参数知识点
    下面展示一些 内联代码片。

高阶函数：就是将函数作为参数传入。

例子：def 函数名（参数1，参数2，…，函数参数）
return 函数参数(参数1)+函数参数(参数2)

// A code block
list = [{'name': 122}, {'name': 1233}, {'name': 345}]
key=lambda x: x['name']
list.sort(key=key)
print(list)
list =[354,23,4343,432]
list.sort()
list =[354,23,4343,432]
list.sort(key=lambda x:x)
print(list)

// An highlighted block
list = [{
     'name': 122}, {
     'name': 1233}, {
     'name': 345}]
key1=lambda x: x['name']
list.sort(key=key1)
print(list)
list =[354,23,4343,432]
list.sort()
list =[354,23,4343,432]
list.sort(key=lambda x:x)
print(list)

文件操作：

打开：

1. open(name,mode，encoding) name : 一个包含了你要访问的文件名称的字符串值。mode 决定了打开文件的模式：只读，写入，追加等字符串值。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读( r )。encoding=‘utf-8’ 输入中文时可以防止乱码
   语法：file = open(name,mode) file对象名
2. mode可以省略，默认为只读。

mode	解释
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

读写操作

1. **write()**写入
   语法：文件对象名.write(字符串)

2. **close()**关闭
   语法：文件对象名.close()

3. 文件操作完后必须关闭（close）进程。

4. read(num) 读
   语法：文件对象名.read(num) num表示从文件中读取的数据的长度(单位是字节)，没有num，则读取所有数据。文件中有换行是占一个字节。

5. readlines()
   **语法：文件对象名.readlines()**可以按照一行来读取内容，返回一个列表，每一行的内容就是一个元素。可以由 Python 的 for… in … 结构进行处理。

6. readline()
   语法：文件对象名.readline() 一次读一行内容。

7. seek( offset,whence)
   语法：文件对象名.seek() 用来移动文件指针。
   offset – 开始的偏移量，也就是代表需要移动偏移的字节数。whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

文件备份：

1. 接受用户的文件：输入用户的文件。input() 文件名加后缀

2. 提取后缀：找到名字中的点，以最右边的为准rfind()，字符串切片找的文件名。

3. 打开文件看，读取文件，创建文件。不确定文件大小，可以循环读取。
   
   后续补代码

文件操作和文件夹的操作：

4. 导包：import os
   语法：os.函数名() 使用os里的功能。

rename()：重命名

5. os.rename(src, dst) src – 要修改的目录名。dst – 修改后的目录名

remove()：删除

1. os.remove(path) path – 要移除的文件路径或者文件名。如果指定的路径是一个目录，将抛出OSError。

mkdir()：创建文件夹

2. os.mkdir(path, mode) path – 要创建的目录路径或者文件名
   mode – 要为目录设置的权限数字模式

rmdir()：删除文件夹

1. os.rmdir(path) path – 要删除的目录路径或者文件名

getcwd()：获得当前目录

1. os.getcwd() 无参数，返回值：返回当前进程的工作目录。

改变默认目录：

2. os.chdir(path) path – 要切换到新的路径。如果允许访问返回 True , 否则返回False。

listdir()：获得当前目录列表

1. os.listdir(path) path – 需要列出的目录路径。返回值：返回指定路径下的文件和文件夹列表。如果目录名字为中文 需要转码处理。

面向对象基础：

类：

1. 语法：class 类名()：
   代码
   …

对象：

2. 创建对象：
   对象 = 类名()

3. 使用对象方法：
   对象.函数方法()

4. 对象属性：即特征
   语法：对象名.属性名 = 值在类外面赋值
   对象名.属性名 类外面获取属性名。
   或者：self.属性名 类里面的获取属性名。

函数方法：

1. def 函数名(self)： self 代表的是类的实例，代表当前对象的地址。

类方法：

1. 需要用装饰器**@classmethod来表示类方法，第一个参数必须是类对象。一般以cls**作为第一个参数。

2. 方法中需要使用类对象时(例访问私有对象时)

3. classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等

4. 语法：
   **@classmethod
   def 方法名(cls):
   … **

静态方法：

5. 静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用，也可以使用对象名调用。

6. 语法：
   **@staticmethod
   def 方法名(cls):
   … **

魔法方法：

2. _ xx _() 的函数就叫魔法方法，具有特殊功能的函数方法。

3. init 的方法作用：初始化对象。

4. init 的方法，在创建时就自动调用。_init_的self参数解释器会自己调用当前对象引用传过去。

5. 带参的_ init _ ，创建对象时需要传参。创建多个对象，每个对象有不同的初始属性。

6. 语法： def init(self, 参数1, 参数2,…)
   self.参数1 = 值
   self.参数2 = 值
   …

7. 当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据。__str__方法需要返回一个字符串，当做这个对象的描写。

8. 语法： def str(self):
   return 字符串

9. 调用__del__() 销毁对象，释放其空间。会自动调用。程序执行即将结束时也会调用 __ del __() 方法

10. 语法： def del(self) :
    代码…

类属性和实例属性:

设置和访问类属性：

1. 语法：class 类名()：
   属性名 = 值
   …

2. 访问：类名.属性名或者对象名.属性名

3. 修改类属性：类名.属性名 = 值 不能通过对象名.属性名调用，实则是创建了实例属性。

继承：

1. 子类默认继承父类的所有属性和方法。

2. 语法： class 子类名(父类名)：
   代码

3. 子类与父类拥有同名的属性和方法时，执行子类的方法和属性。

4. 子类可以继承父类的私有属性和方法，但是不能直接访问。

多继承：

1. 语法： class 子类名(父类名1，父类名2，…)：
   代码
   当子类继承多个父类时，默认使用第一个类的同名属性和方法。

重写：

2. 子类和父类拥有同名的方法和属性，子类重新书写方法和属性的内容。子类调用的就是子类的方法。

3. 继承关系查看:print(类名.__ mro __)

super():

4. super()：子类中调用父类的方法和属性。super().xxx 或者**super(Class, self).xxx ** Class 是当前类

私有属性:

1. 类的私有属性__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

2. 类的方法在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个

3. 参数类的私有方法 __private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

4. Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName（ 对象名._类名__私有属性名 ）访问属性

5. 可以类的内部添加函数来修改和获得私有属性，例子：def get_名字:或者set_名字。

异常：

异常的知识点：

6. 异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。一般情况下，在Python无法正常处理程序时就会发生一个异常。异常是Python对象，表示一个错误。当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

异常名称	描述
BaseException	所有异常的基类
SystemExit	解释器请求退出
boardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxErrorPython	语法错误
IndentationError	缩进错误
TabError Tab	和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError Unicode	解码时的错误
UnicodeEncodeError Unicode	编码时错误
UnicodeTranslateError Unicode	转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

异常的写法：

1. 语法：try：
   可能发生的异常代码
   except 异常类型：
   如果发生异常时执行的代码只有可能发生的异常代码类型与发生的异常的代码类型一致才可以捕获。

2. try一般只放一行报出异常的代码。

多个异常代码报错

3. 语法：try：
   可能发生的异常代码
   except (异常类型1，异常类型2，…):
   如果发生异常时执行的代码 多个异常错误类型需要放在except后面用元组书写。

捕获异常代码信息：

1.   try：
   	可能发生的异常代码
      except (异常类型1，异常类型2，......) as 异常信息接收变量名:
   	print(异常信息接收变量名)
   	如果发生异常时执行的代码
   

捕获所有异常信息：

2. Exception是所有异常类的父类

3.   try：
   	可能发生的异常代码
    except Exception as 异常信息接收变量名:
   	print(异常信息接收变量名)
   	如果发生异常时执行的代码
   

异常的else：

4. else是如果没有异常时发生的代码。try… else…也可以

5. try：
   	可能发生的异常代码
   except Exception as 异常信息接收变量名:
    	print(异常信息接收变量名)
    	如果发生异常时执行的代码
   else： 
    	没有异常时的代码。
   

finally的异常：

6. 无论是否异常都需要执行的语句。try…fianlly 也可以。

7. try：
   	可能发生的异常代码
   except Exception as 异常信息接收变量名:
   	print(异常信息接收变量名)
   	如果发生异常时执行的代码
   else：
   	语句1
   finally：
   	语句2
   

自定义异常：

1. 使用：raise 异常类对象
2. 定义异常类去继承exception的类，用__str__返回异常信息。

模块和包 ：

模块：

1. Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
   模块让你能够有逻辑地组织你的 Python 代码段。
   把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
   模块能定义函数，类和变量，模块里也能包含可执行的代码。

2. import module , module2,… 导入模块，其调用功能：模块名.功能名().

3. from modname import 功能1, 功能2, … Python 的 from 语句让你从模块中导入模块的相关功能中，直接可以用功能名使用。

4. from modname import（*） 把一个模块的所有内容全都导入到当前的命名空间，直接可以用功能名使用。

as定义别名（自己写名字，方便看懂）：

5. import module as 别名 ，把模块名修改别名，使用模块是只能用别名。

6. from modname import 功能 as 别名 把模块的功能名修改别名，使用模块是只能用别名。

制作模块：

1. 定义模块，新建py文件，定义函数。

2. 当你导入一个模块，Python 解析器对模块位置的搜索顺序是：
   1、当前目录
   2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
   3、如果都找不到，Python会查看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

3. 自己的文件名不能和已有的模块重名。

4. 使用from modname import 功能1时，功能名一样时，调用的是最后导入或定义的功能

5. 避免名字重复，在Python中数据是通过引用的传递的，后者数据会覆盖前者。

6. 测试模块：在自定义的模块功能中要添加测试数据，在测试数据前要条件语句控制只能在该模块文件中使用.
   if name == ‘main’:
   测试数据 _ name 是系统变量，是模块标识符。值是：如果是自身模块，值是 main _,否则是当前模块名。

新建包：

1. 包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
   简单来说，包就是文件夹，但该文件夹下必须存在 __ init __ .py 文件, 该文件的内容可以为空。__ init __.py 用于标识当前文件夹是一个包，这个问件控制包的导入行为。

2. 新建包（Python package）时会自动创建__ init __.py文件，可以写模块。

导入包：

1. import 包名.模块名
   调用功能：包名.模块名.功能名

2. 必须在__ init __.py文件中添加 __ all __ = [ ]，控制允许导入的模块列表。from modname import（*）
   调用功能：模块名.功能名