【无标题】

1. 写代码一定要注意格式，良好的代码格式可提升代码的可读性.
   eg.
   #第一个注释
   print（’’ Hello,Python!’’) #第二个注释
   ～单行注释以#开头～

eg.
‘’‘’‘’
print（value,…,sep=’’…）
‘’‘’‘’
～多行注释由三引号或单引号组成～
2.python的缩进可用Tab键，也可用空格.
3.熟记标识符和关键字、各类运算符.
（标识符由字母、下划线和数字组成，且数字不能开头，标识符是区分大小写的哦，标识符不能使用关键字）
4.变量和数据类型.
eg.
data=100
～python通过赋值运算符‘’=‘’将数值与变量名建立联系，即定义变量～
数据类型的分类：
数字类型（numbers）：
整型（int）、浮点型（float）、复数类型（complex）
字符串类型（str）
列表类型（list）
元组类型（tuple）
字典类型（dict）
集合类型（set）
～布尔类型（bool）比较特殊，它是int的子类哦～
～字符串是由单引号、双引号或三引号包裹的、有序的字符集合~
字符串相关知识点补充：
(1) 使用‘’\‘’转义
\b退格、\n换行、\v纵向制表符、\t横向制表符、\r回车
(2) 使用‘’%‘’格式化字符串
format%values
(format是字符串，values是真实数据)
(3) 使用format()方法格式化字符串
str.format(values)
(str是字符串，values是真实数据)
(4) 使用f-string格式化字符串
f(‘{变量名}’或F(‘{变量名}’)
(5) 字符串的查找与替换
str.find(sub[,start[,end]])
sub是指定要查找的子串，start是开始索引，默认为0，end是结束索引，默认为字符串的长度
str.replace(old,new[,count])
old是被替换的旧子串，new是替换旧子串的新子串，count是表示替换旧字符串的次数，默认全部替换
(6) 字符串的分隔与拼接
str.split(sep=None,maxsplit=-1)
sep是分隔符，默认为空字符，maxsplit是分割次数，默认值为-1，表示不限制分割次数）
str.join(iterable)
iterable是表示连接字符串的字符
(7) 删除字符串的指定字符
upper()
将字符串中的小写字母转为大写字母
lower()
将字符串中的大写字母转为小写字母
capitalize()
将字符串中第一个字母转为大写
title()
将字符串中每个单词首字母转为大写
(8) 字符串对齐
str.center(width[,fillchar])
原字符串居中显示
str.ljust(width[,fillchar])
原字符串左对齐显示
str.rjust(width[,fillchar])
原字符串右对齐显示
～列表是多个元素的集合，使用[]创建空列表~
列表相关知识点补充：
(1) 使用[]创建空列表
list_one=[ ]
(2) 使用list()创建空列表
li_two=list()
使用list()创建空列表
(3)使用isinstance()判断目标是否为可迭代对象
(4)访问列表元素，可通过切片或索引访问，也可在循环中依次访问
索引 print(list_one[1])
切片 print(list_one[1])
循环 for li in li_one:
print(li,end=‘’)
(5)添加列表元素
list_one.append(‘’C++’’)
append指在列表末尾添加元素
list_one.extend([[“Android”,”IOS”,])
extend指在列表末尾添加另一个序列的所有元素
list_one.insert(2,”HTML”)
insert指按照索引将元素插入列表的指定位置
(6)元素排序
list_one.sort()
sort指有序的元素会覆盖原来的列表元素，不产生新列表
li_two=sorted(li_one)
sorted指产生排序后的新列表，排序操作不会对原列表产生影响
li_one.reverse()
reverse指逆置列表，把原列表中元素从右至左依次排列存放
(7)删除列表元素
del li_one[0]
删除列表指定元素
li_one.remove(3)
remove指移除列表中匹配到的第一个元素
li_one.pop()
pop指移除列表中的某个元素，若未指定，则移除最后一个
li_one.clear()
clear指清空列表
～元组与列表相似，但需要记住的是不可以被修改哦~
元组相关知识点补充：
(1) 使用索引tuple_demo[2]
(2) 使用切片 tuple_demo[2:5]
(3) 遍历元组 for i in tuple_demo：
print(i)
～集合与列表和元组类似，不同的是集合使用{}创建，集合中元素无序且唯一～

～字典中的元素是‘’键：值‘’，键不能重复，要记清楚用{}创建字典，字典的每个键只能对应一个值，字典中的键是不可变类型.字典的值通过键访问，d2 [‘A’]，通过get()访问，d2.get（‘B’）~

5.数字类型的类别要分清.
整数类型（int）
～以4种（二进制、八进制、十进制、十六进制）计数方式表示，分别对应以下几种转换数据进制的函数～
Bin(x) 将x转换为二进制数据
Oct(x) 将x转换为八进制数据
int (x) 将x转换为十进制数据
hex(x) 将x转换为十六进制数据
浮点型（float）
复数类型
布尔类型
～只有True和False两个取值，True对应整数1，False对应整数0～

补充一个知识点！这是一个重重重点！！！
数字类型的转换
int(x[,base]) 将x转换为一个整型数据
float(x) 将x转换为一个浮点型数据
complex(x) 将x转换为复数类型
6.函数 划重点哦
(1)函数的定义和调用
def add():
result=11+22
print(result)
//无参函数

def add_modify(a,b):
result=a+b
print(result)
//有参函数

_{函数在定义完成后不会立刻执行，直到被程序调用时才会执行}
add()
add_modify(10,20)
_{程序在调用函数的位置暂停执行
将数据传递给函数参数
执行函数体中的语句
程序回到暂停处继续执行
函数内部也可调用其他函数，称为函数的嵌套调用}
def add_modify(a,b):
result=a+b
add() //嵌套调用函数add()
print(result)
add_modify(10,20)

(2) 函数参数的传递
将定义函数设置的参数称为形参
将调用函数时传入的参数称为实参
函数的参数传递指将实际参数传递给形式参数的过程

位置参数的传递
def get_max(a,b):
if a>b:
print(a,”是较大的值！“)
else:
print(b,”是较大的值！“)
get_max(8,5) //8是较大的值

关键字参数的传递
~通过“形参=实参“将实参与形参相关联
def connect(ip,port):
print(f”设备{ip}:{port}连接!”)
connect(ip=”127.0.0.1”,port=8080)

默认参数的传递
函数在定义时可以指定形参默认值，被调用时可以选择是否给带默认值的形参传值，若未给带默认值的形参传值，则直接使用该形参的默认值

def connect(ip,port=8080):
print(f”设备{ip}:{port}连接!”) //定义
connect(ip=”127.0.0.1”)
connect(ip=”127.0.0.1”,port=3306) //调用
设备127.0.0.1:8080连接!
设备127.0.0.1:3306连接!

参数的打包与解包
函数在定义时无法确定接收多个数据，可在定义函数时为形参添加“”或”**“
“” 接收以元组形式打包的多个值
“**” 接收以字典形式打包的多个值
(1)打包“*“
def test(*args):
print(args) //定义
test(11,22,33,44,55) //调用
(11,22,33,44,55) //结果

打包”**”
def test(kwargs):
print(kwargs) //定义
test(a=11,b=22,c=33,d=44,e=55)
{‘a’:11,’b’:22,’c’:33,’d’:44,’e’:55} //结果
_{参数*args和**kwargs为空，为空元组或空字典}
(2)解包
实参是元组，可以使用”*”拆分成多个值，按位置参数传给形参
实参是字典，可以使用””拆分成多个键值对，按关键字参数传给形参
def test(a,b,c,d,e):
print(a,b,c,d,e) //定义
nums=(11,22,33,44,55)
test(*nums) //调用
{‘a’:11,’b’:22,’c’:33,’d’:44,’e’:55} //结果

def test(a,b,c,d,e):
print(a,b,c,d,e) //定义
nums={“a”:11,”b”:22,”c”:33,”d”:44,”e”:55}
test(**nums) //调用
11 22 33 44 55 //结果

混合传递
在定义函数或调用时可以混合使用
def test(a,b,c=33,*args,**kwargs):
print(a,b,c,args,kwargs) //定义
test(1,2)
test(1,2,3)
test(1,2,3,4)
test(1,2,3,4,e=5) //调用
1 2 33 () {}
1 2 3 () {}
1 2 3 (4,) {}
1 2 3 (4,) {‘e’:5} //结果

7.变量作用域
(1) 局部变量和全局变量
函数内部定义的变量，只能在函数内部被使用
函数执行结束之后局部变量会被释放，此时无法再进行访问
局部变量
def test_one():
number=10 //局部变量
print(number) //函数内部访问局部变量
test_one()
print(number) //函数外部访问局部变量

_{不同函数内部可以包含同名的局部变量}
def test_one():
number=10
print(number) //访问test_one()函数的局部变量number
def test_two():
number=20
print(number) //访问test_two()函数的局部变量number

全局变量
number=10 //全局变量
def test_one():
print(number) //函数内部访问全局变量
test_one()
print(number) //函数外部访问全局变量
_{全局变量在函数内部只能被访问，而无法直接修改}
number=10
def test_one():
print(number)
number+=1
test_one()
print(number)

(2) 递归函数
函数定义时可直接或间接调用其他函数，若函数内部调用了自身，则称递归函数
在定义时需满足两个基本条件：递推公式和边界条件
def函数名([参数列表]):
if边界条件:
return结果
else:
return递归公式
递归经典应用(阶乘n!)
n!=123*…*n,可以分为以下两种情况：

1. 当n=1时，所得的结果为1 //边界条件
2. 当n>1时，所得的结果为n*(n-1)! //递归公式
   eg.
   def func(num):
   if num==1:
   return 1
   else:
   return num*func(num-1)
   num=int(input(“请输入一个整数:”))
   result=func(num)
   print(“5!=%d”%result)

(3) 匿名函数
使用lambda定义匿名函数
lambda<形式参数列表>:<表达式>
_{匿名函数没有名称，函数体只能是一个表达式，不能被其他程序使用}
temp=lambda x:pow(x,2)
temp(10)

8.文件与数据格式化
(1) 文件概述
文件标识的组成：文件路径，文件名主干，文件扩展名
sys模块中定义了3个标准文件：stdin(标准输入文件)，stdout(标准输出文件)，stderr(标准错误文件)
eg.
import sys
file=sys.stdout
file.write(“hello”)

(3) 文件的基本操作
1.打开文件
open(file,mode=’r’,buffering=-1)
file：文件的路径
mode：设置文件的打开模式，取值有r,w,a
_{r以只读方式打开文件，w以只写方式打开文件，a以追加方式打开文件，b以二进制形式打开文件，+以更新的方式打开文件}
buffering：设置访问文件的缓冲方式，取值为0或1
补充打开文件知识点：
r/rb 只读模式
w/wb 只写模式
a/ab 追加模式
r+/rb+ 读取（更新）模式
w+/wb+ 写入（更新）模式
a+/ab+ 追加（更新）模式
3.关闭文件
close()方法
file.close()
with语句
with open(‘a.txt’) as f:
pass
4.文件的读写
读取文件 read()方法
_{read方法可以从指定文件中读取指定字节的数据}
with open(‘file.txt’,mode=’r’) as f:
print(f.read(2)) //读取两个字节的数据
print(f.read()) //读取剩余的全部数据
读取文件 readline()方法
_{readline()方法可以从指定文件中读取一行数据}
with open(‘file.txt’,mode=’r’,encoding=’utf-8’) as f:
print(f.readline())
print(f.readline())
_{readlines()方法可以一次读取文件中的所有数据，读取成功，方法会返回出一个列表，文件中的每一行对应列表中的一个元素}
with open(‘file.txt’,mode=’r’,encoding=’utf-8’) as f:
print(f.readlines())

写文件 write()方法
string=”Here we are all,by day;by night.” //字符串
with open(‘write_file.txt’,mode=’w’,encoding=’utf-8’) as f:
size=f.write(string) //写入字符串
print(size) //打印字节数
写文件 writelines()方法
_{writelines()方法用于将行列表写入文件}
string=”Here we are all,by day;\nby night we’re hurl’d By dreams,each one into a several world.”
with open(‘write_file.txt’,mode=’w’,encoding=’utf-8’) as f:
f.writelines(string)

5.文件的定位读写
tell() 获取文件当前的读写位置
seek() 控制文件的读写位置
tell()方法
with open(‘file,txt’) as f:
print(f.tell()) //获取文件读写位置
print(f.read(5)) //利用read()方法移动文件读写位置
print(f.tell()) //再次获取文件读写位置

seek()方法
seek(offset,from)
offset：表示偏移量，即读写位置需要移动的字节数
from：用于指定文件的读写位置，该参数的取值为0，1，2
_{0表示文件开头，1表示使用当前读写位置，2表示文件末尾
seek()方法调用成功后会返回当前读写位置
若打开的是文本文件，那么seek()方法只允许相对于文件开头移动文件位置，在参数from值为1，2的情况下对文本文件进行位移操作，将会产生错误}
with open(‘file.txt’,’rb’) as f:
f.seek(5,0)
f.seek(3,1)
_{若要相对当前读写位置或文件末尾进行位移操作，需以二进制形式打开文件}

6.文件与目录管理
删除文件 os.remove(文件名)
文件重命名 os.rename(原文件名，新文件名)
创建/删除目录 os.mkdir(目录名)/os.redir(目录名)
获取当前目录 os.getcwd()
更改默认目录 os.chdir(路径名)
获取目录列表 os.listdir(目录/路径)