Python小总结//

一.写代码一定要注意格式，良好的代码格式可提升代码的可读性.

eg.  

#第一个注释

print（“ Hello,Python!’’) #第二个注释

～单行注释以#开头～

eg.

‘’‘’‘’

print（value,...,sep=’’...）

‘’‘’‘’

～多行注释由三引号或单引号组成～

二.python的缩进可用Tab键，也可用空格.

三.熟记标识符和关键字、各类运算符.

（标识符由字母、下划线和数字组成，且数字不能开头，标识符是区分大小写的哦，标识符不能使用关键字）

四.变量和数据类型.

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.字符串的查找与替换

(1)str.find(sub[,start[,end]])

(sub是指定要查找的子串，start是开始索引，默认为0，end是结束索引，默认为字符串的长度)

(2)str.replace(old,new[,count])

(old是被替换的旧子串，new是替换旧子串的新子串，count是表示替换旧字符串的次数，默认全部替换)

6.字符串的分隔与拼接

(1)str.split(sep=None,maxsplit=-1)

(sep是分隔符，默认为空字符，maxsplit是分割次数，默认值为-1，表示不限制分割次数）

(2)str.join(iterable)

(iterable是表示连接字符串的字符)

7.删除字符串的指定字符

(1)upper()

(将字符串中的小写字母转为大写字母)

(2)lower()

(将字符串中的大写字母转为小写字母)

(3)capitalize()

(将字符串中第一个字母转为大写)

(4)title()

(将字符串中每个单词首字母转为大写)

8.字符串对齐

(1)str.center(width[,fillchar])

(原字符串居中显示)

(2)str.ljust(width[,fillchar])

(原字符串左对齐显示)

(3)str.rjust(width[,fillchar])

(原字符串右对齐显示)

～列表是多个元素的集合，使用[]创建空列表~

列表相关知识点补充：

1.使用[]创建空列表

list_one=[ ]

2.使用list()创建空列表      

li_two=list()

使用list()创建空列表

3.使用isinstance()判断目标是否为可迭代对象

4.访问列表元素，可通过切片或索引访问，也可在循环中依次访问

(1)索引 print(list_one[1])

(2)切片 print(list_one[1])

(3)循环 for li in li_one:

                    print(li,end=‘’)

5.添加列表元素

(1)list_one.append(‘’C++'')

(append指在列表末尾添加元素)

(2)list_one.extend([[“Android”,”IOS”,])

(extend指在列表末尾添加另一个序列的所有元素)

(3)list_one.insert(2,"HTML")

(insert指按照索引将元素插入列表的指定位置)

6.元素排序

(1)list_one.sort()

(sort指有序的元素会覆盖原来的列表元素，不产生新列表)

(2)li_two=sorted(li_one)

(sorted指产生排序后的新列表，排序操作不会对原列表产生影响)

(3)li_one.reverse()

(reverse指逆置列表，把原列表中元素从右至左依次排列存放)

7.删除列表元素

(1)del li_one[0]

(删除列表指定元素)

(2)li_one.remove(3)

(remove指移除列表中匹配到的第一个元素)

(3)li_one.pop()

(pop指移除列表中的某个元素，若未指定，则移除最后一个)

(4)li_one.clear()

(clear指清空列表)

～元组与列表相似，但需要记住的是不可以被修改哦~

元组相关知识点补充：

1. 使用索引tuple_demo[2]
2. 使用切片 tuple_demo[2:5]
3. 遍历元组 for i in tuple_demo:
4.                      print(i)

～集合与列表和元组类似，不同的是集合使用{}创建，集合中元素无序且唯一～

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

五.数字类型的类别要分清.

整数类型（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转换为复数类型

六.函数 划重点哦

1.函数的定义和调用

eg.

def add():

  result=11+22

  print(result) 

//无参函数

eg.

def add_modify(a,b):

  result=a+b

  print(result)

//有参函数

~函数在定义完成后不会立刻执行，直到被程序调用时才会执行~

eg.

add()

add_modify(10,20)

~程序在调用函数的位置暂停执行~

~将数据传递给函数参数~

~执行函数体中的语句~

~程序回到暂停处继续执行~

~函数内部也可调用其他函数，称为函数的嵌套调用~

eg.

def add_modify(a,b):

  result=a+b

  add()               //嵌套调用函数add()

  print(result)

add_modify(10,20)

2.函数参数的传递

将定义函数设置的参数称为形参

将调用函数时传入的参数称为实参

函数的参数传递指将实际参数传递给形式参数的过程

(1)位置参数的传递

eg.

def get_max(a,b):

  if a>b:

print(a,”是较大的值！“)

   else:

     print(b,”是较大的值！“)

get_max(8,5)                  //8是较大的值

(2)关键字参数的传递

通过“形参=实参“将实参与形参相关联

eg.

def connect(ip,port):

  print(f”设备{ip}:{port}连接!”)

connect(ip=”127.0.0.1”,port=8080)

(3)默认参数的传递

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

eg.

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连接!

(4)参数的打包与解包

函数在定义时无法确定接收多个数据，可在定义函数时为形参添加“*”或“**”

“*”  接收以元组形式打包的多个值

“**”  接收以字典形式打包的多个值

打包“*”

eg.

def test(*args):

  print(args)  //定义

test(11,22,33,44,55)  //调用

(11,22,33,44,55)  //结果

打包“**”

eg.

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为空，为空元组或空字典~

解包

实参是元组，可以使用”*”拆分成多个值，按位置参数传给形参

实参是字典，可以使用”**”拆分成多个键值对，按关键字参数传给形参

eg.

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}  //结果

eg.

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  //结果

(5)混合传递

在定义函数或调用时可以混合使用

eg.

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}  //结果

七.变量作用域

1.局部变量和全局变量

函数内部定义的变量，只能在函数内部被使用

函数执行结束之后局部变量会被释放，此时无法再进行访问

(1)局部变量

eg.

def test_one():

  number=10  //局部变量

  print(number)  //函数内部访问局部变量

test_one()

print(number)  //函数外部访问局部变量

~不同函数内部可以包含同名的局部变量~

eg.

def test_one():

  number=10

print(number)  //访问test_one()函数的局部变量number

eg.

def test_two():

  number=20

  print(number)  //访问test_two()函数的局部变量number

(2)全局变量

eg.

number=10  //全局变量

def test_one(): 

  print(number)  //函数内部访问全局变量

test_one()

print(number)  //函数外部访问全局变量

~全局变量在函数内部只能被访问，而无法直接修改~

eg.

number=10

def test_one():

  print(number)

  number+=1

test_one()

print(number)

八.特殊形式的函数.

1.递归函数

函数定义时可直接或间接调用其他函数，若函数内部调用了自身，则称递归函数

在定义时需满足两个基本条件：递推公式和边界条件

eg.

def函数名([参数列表]):

        if边界条件:

                return结果

        else:

                return递归公式

递归经典应用(阶乘n!)

n!=1*2*3*…*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)

2.匿名函数 

使用lambda定义匿名函数

lambda<形式参数列表>:<表达式>

~匿名函数没有名称，函数体只能是一个表达式，不能被其他程序使用~

eg.

temp=lambda x:pow(x,2)

temp(10)

九.文件与数据格式化

1.文件概述

文件标识的组成：文件路径，文件名主干，文件扩展名

sys模块中定义了3个标准文件：stdin(标准输入文件)，stdout(标准输出文件)，stderr(标准错误文件)

eg.

import sys

file=sys.stdout

file.write(“hello”)

文件的基本操作

(1)打开文件

eg.

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+ 追加（更新）模式

(2)关闭文件

close()方法

eg.

file.close()

with语句

with open(‘a.txt’) as f:

pass

(3)文件的读写

读取文件 read()方法

~read方法可以从指定文件中读取指定字节的数据~

eg.

with open(‘file.txt’,mode=’r’) as f:

  print(f.read(2))  //读取两个字节的数据

  print(f.read())   //读取剩余的全部数据

读取文件 readline()方法

~readline()方法可以从指定文件中读取一行数据~

eg.

with open(‘file.txt’,mode=’r’,encoding=’utf-8’) as f:

  print(f.readline())

  print(f.readline())

~readlines()方法可以一次读取文件中的所有数据，读取成功，方法会返回出一个列表，文件中的每一行对应列表中的一个元素~

eg.

with open(‘file.txt’,mode=’r’,encoding=’utf-8’) as f:

  print(f.readlines())

写文件 write()方法

eg.

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()方法用于将行列表写入文件~

eg.

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)

(4)文件的定位读写

tell() 获取文件当前的读写位置

seek() 控制文件的读写位置

tell()方法

eg.

with open(‘file,txt’) as f:

  print(f.tell())  //获取文件读写位置

  print(f.read(5))  //利用read()方法移动文件读写位置

print(f.tell())  //再次获取文件读写位置

seek()方法

eg.

seek(offset,from)

offset：表示偏移量，即读写位置需要移动的字节数

from：用于指定文件的读写位置，该参数的取值为0，1，2

~0表示文件开头，1表示使用当前读写位置，2表示文件末尾~

~seek()方法调用成功后会返回当前读写位置~

~若打开的是文本文件，那么seek()方法只允许相对于文件开头移动文件位置，在参数from值为1，2的情况下对文本文件进行位移操作，将会产生错误~

eg.

with open(‘file.txt’,’rb’) as f:

  f.seek(5,0)

  f.seek(3,1)

~若要相对当前读写位置或文件末尾进行位移操作，需以二进制形式打开文件~

(5)文件与目录管理

删除文件 os.remove(文件名)

文件重命名 os.rename(原文件名，新文件名)

创建/删除目录 os.mkdir(目录名)/os.redir(目录名)

获取当前目录 os.getcwd()

更改默认目录 os.chdir(路径名)

获取目录列表 os.listdir(目录/路径)