python基础总结

为什么我要总结

应为就是编程语言学习的多了容易搞混，比如c语言的数组和python的列字典等搞混

还有我英语真的是小学等级的很多函数方法属性记不住我就写到这个了

总结方法/函数

修改字符串

方法/函数	作用
title()方法	这个方法可以叫字符串首字母修改成大写
rstrip()方法	方法会移出尾的空格
strip()方法	方法会移出头和尾的空格

增加元素

方法/函数	作用
append()方法	这个方法会在列表最后增加元素
insert()方法	这个方法可以在选择在那个地址增加元素

删除元素

方法/函数	作用
del语句	指定删除如何变量或元素字典
pop()方法	删除指定的元素,如果不指定默认删除最后一个,他返回被删除的值
remove()方法	指定元素内容删除

列表排序

方法/函数	作用
sort()方法	他会按大小进行排序，他是永久性的
sorted()函数	他会按大小进行排序，他是临时排序的
reverse()方法	倒着排序

查看列表长度

方法/函数	作用
len()函数	查看列表长度

便利键值对

方法/函数	作用
items()方法	返回值返回可遍历的键, 值列表
keys()方法	返回值返回可遍历的键列表
values()方法	返回值返回可遍历的值列表

while循环常用的函数

函数	作用
break函数	退出循环
continue函数	结束一次循环

查看可以用属性/方法

方法/函数	作用
dir()函数	此函数会返回所现在可以用的属性和方法

id函数

方法/函数	作用
id函数	查看变量或其他的他所在的内存地址

查看可以用属性/方法

方法/函数	作用
dir()函数	此函数会返回所现在可以用的属性和方法

实现

>>> name=['a','b']
>>> dir(name)
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

下面我就用一个remove方法

remove方法指定元素内容删除

>>> name=['a','b']
>>> name.remove('a')
>>> print(name)
['b']

文件操作

文件操作常用到的函数

方法/函数	作用
open()函数	打开文件，并返回文件的对象
close()方法	关闭文件
read()方法	读取整个文件，将文件内容放到一个字符串变量中
readline()方法	读取一行，然后他会移动到下一行
write() 函数	可以向文件中写入指定内容

OS 模块

应为OS模块文件太多了我就列出几个常用的

os模块常用方法	相应的作用
os.getcwd()	返回当前工作目录
os.listdir(文件夹名)	目录列表
os.mkdir(文件夹名)	创建文件，只能创建一个单层文件，而不能嵌套创建，若文件夹存在则会抛出异常
os.makedirs(文件夹名/文件夹名)	创建多层目录 ，可以嵌套创建
os.rmdir(文件夹名)	删除单层目录，遇见目录非空时则会抛出异常
os.rename(文件名,文件名)	修改文件名

判断函数

函数	作用
type()	返回对象的类型
isinstance()	如果要判断两个类型是否相同推荐使用

异常处理

函数/关键字	作用
raise	关键字用于引发异常

数据类型强制转换函数

函数	强制转换
int()	数字
str()	字符串
bool()	布尔值
list()	列表
tuple()	元组
dict()	字典

常用的函数

函数/方法	作用
split()	通过指定分隔符对字符串进行切片
isinstance()	函数来判断一个对象是否是一个已知的类型，类似 type()
zip()	可以将多个列表、元组、字典、字符串等“压缩”成一个 zip 对象
join()	方法用于将序列中的元素以指定的字符连接生成一个新的字符串

字符串修改

修改字符串

方法/函数	作用
title()方法	这个方法可以叫字符串首字母修改成大写
rstrip()方法	方法会移出尾的空格
strip()方法	方法会移出头和尾的空格
zip()函数	他可以叫元素，列表，字典，字符串等打包成成一个 zip 对象
list()函数

1. title()方法

   这个方法可以叫字符串首字母修改成大写

   >>> name="abc dcf" 
   >>> print(name.title()) 
   Abc Dcf 
   >>> 

2. rstrip()和strip()方法

   rstrip()方法会移出尾的空格

   strip()方法会移出头和尾的空格

   下面是rstrip()方法

   >>> name="  abc  "    
   >>> print(name.rstrip()) 
   ' abc '
   >>> 

下面是rstrip()方法

   >>> name="  abc  "    
   >>> print(name.strip()) 
'abc'
   >>> 

列表

python的列是用[]来声明的里面的内容叫元素

C语言的数组是这样声明的

int a[]={'a','b','c'};

python的列是这样声明的

a['a','b','c']

修改元素

>>> name=['a','b','c']
>>> name[0]='b'
>>> print(name)
['b', 'b', 'c']

增加元素

方法/函数	作用
append()方法	这个方法会在列表最后增加元素
insert()方法	这个方法可以在选择在那个地址增加元素

append()方法

这个方法会在列表最后增加元素

>>> name=['a','b','c']
>>> print(name)
['a', 'b', 'c']
>>> name.append('d')
>>> print(name)
['a', 'b', 'c', 'd']
>>> 

insert()方法

>>> name=['a','b','c']
>>> print(name)
['a', 'b', 'c']
>>> name.insert(2,'b')
>>> print(name)
['a', 'b', 'b', 'c']
>>> 

删除元素

方法/函数	作用
del语句	指定删除如何变量或元素字典
pop()方法	删除指定的元素,如果不指定默认删除最后一个,他返回被删除的值
remove()方法	指定元素内容删除

del语句

指定删除如何变量或元素字典

>>> name=['a','b','c']
>>> print(name)
['a', 'b', 'c']
>>> del name[1]
>>> print(name)
['a', 'c']
>>> 

如果不指定

>>> name=['a','b','c']
>>> del name
>>> print(name)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'name' is not defined
>>> 

指定删除变量

>>> name=1
>>> del name
>>> print(name)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'name' is not defined

pop()方法

删除指定的元素,如果不指定默认删除最后一个,他返回被删除的值

>>>name=['a','b','c']
>>>name.pop()
>>>print(name)
['a', 'b']

查看他的返回值

可以看见他的值是c,就是叫c给删除了

>>> name=['a','b','c']
>>> print(name.pop())
c
>>> 

指定删除

>>> name=['a','b','c']
>>> name.pop(1)
>>> print(name)
['a', 'c']

remove()方法

指定元素内容删除

如果下面有多个b他只会删除第一个b

>>> name=['a','b','c']
>>> name.remove('b')
>>> print(name)
['a', 'c']

列表排序

方法/函数	作用
sort()方法	他会按大小进行排序，他是永久性的
sorted()函数	他会按大小进行排序，他是临时排序的
reverse()方法	倒着排序

sort()方法

他会按大小进行排序，他是永久性的

>>> name=['caa','bcc','add']
>>> name.sort()
>>> print(name)
['add', 'bcc', 'caa']

sorted()函数

记住他是函数

>>> name=['caa','bcc','add']
>>> print(sorted(name))
['add', 'bcc', 'caa']
>>> 

他会按大小进行排序，他是临时排序的

reverse()

倒着排序

>>> name=['a','b','c']
>>> name.reverse()
>>> print(name)
['c', 'b', 'a']

列表长度

用的是len()函数

>>> name=['a','b','c']
>>> print(len(name))
3

列表统计

函数	作用
min()函数	输出最小的元素
max(min)函数	输出最大的元素
sum()方法	输出元素的综合

>>> name=[1,2,3]
>>> min(name)
1
>>> max(name)
3
>>> sum(name)
6

切片

>>> name=[1,2,3,4]
>>> print(name[2:])
[3, 4]

>>> name=[1,2,3,4]
>>> print(name[:3])
[1, 2, 3]

>>> name=[1,2,3,4]
>>> print(name[-3:])
[2, 3, 4]

元组

元组就是一个不能改的列表

>>> name=(1,2,3,4)
>>> name[0]=1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

字典

python的字典声明

下面name这个叫键，123叫值

下面age这个叫键，18叫值

>>> name={'num':123,'age':18}
>>> print(name['num'])
123
>>> print(name['age'])
18

python的字典有点点与c的结构体差不多

c语言的结构体声明

struct name{
    char name;  //姓名
    int num;  //学号
    int age;  //年龄
    char group;  //所在学习小组
    float score;  //成绩
};

python的字典声明

name={'name':'wsdx','num':123,'age':18}

添加键值对

>>> name={'num':123,'age':18}
>>> name['name']='张三'
>>> print(name)
{'num': 123, 'age': 18, 'name': '张三'}

删除键值对

方法/函数	作用
del语句	指定删除如何变量或元素字典

>>> name={'num':123,'age':18}
>>> del name['num']
>>> print(name)
{'age': 18}
>>> 

遍历键值对

方法/函数	作用
items()方法	返回值返回可遍历的键, 值列表

返回值返回可遍历的键, 值列表

查看他的返回键, 值列对表

>>> name={'num':123,'age':18}
>>> print(name.items())
dict_items([('num', 123), ('age', 18)])

遍历键值对

a存储的是键，b存储的是值

>>> name={'num':123,'age':18}
>>> for a,b in name.items():
... 	print("键是"+str(a)+"值是"+str(b))
键是num值是123
键是age值是18

遍历键

方法/函数	作用
keys()方法	返回值返回可遍历的键列表

他的返回

可以看见他返回的里面的键

>>> name={'num':123,'age':18}
>>> print(name.keys())
dict_keys(['num', 'age'])

遍历键

for只需要一个a变量就可以了应为他就一个

>>> name={'num':123,'age':18}
>>> for a in name.keys(): 
...     print(a)
num
age

遍历值

方法/函数	作用
values()方法	返回值返回可遍历的值列表

他的返回

>>> name={'num':123,'age':18}
>>> print(name.values())
dict_values([123, 18])

遍历值

for只需要一个a变量就可以了应为他就一个

>>> name={'num':123,'age':18}
>>> for a in name.values(): 
...     print(a)
123
18

嵌套

这个嵌套就是字典里面套列表，列表里面套字典等等

字典列表

列表里面套字典，就是列表里面是字典

>>> name={'a':123,'b':18}
>>> name2={'c':123,'d':18}
>>> name3=[name,name2]
>>> print(name3)
[{'a': 123, 'b': 18}, {'c': 123, 'd': 18}]

指定输出

我们我们想输出a里面的值

>>> name={'a':123,'b':18}
>>> name2={'c':123,'d':18}
>>> name3=[name,name2]
>>> print(name3[0]['a'])
123

列表字典

字典里面套列表，就是字典里面的值是列表

注意是值不是键

>>> name=['a','b']
>>> name2=['c','d']
>>> name3={'num':name,'age':name2}
>>> print(name3)
{'num': ['a', 'b'], 'age': ['c', 'd']}

指定输出

我们我们想输出a

>>> name=['a','b']
>>> name2=['c','d']
>>> name3={'num':name,'age':name2}
>>> print(name3['num'][0])
a

字典套字典

字典套字典，就是字典里面的值是字典

注意是值不是键

>>> name={'a':123,'b':18}
>>> name2={'c':123,'d':18}
>>> name3={'unm':name,'age':name2}
>>> print(name3)
{'unm': {'a': 123, 'b': 18}, 'age': {'c': 123, 'd': 18}}

指定输出

指定输出指定字典unm键里面的a键里面的值

>>> name={'a':123,'b':18}
>>> name2={'c':123,'d':18}
>>> name3={'unm':name,'age':name2
>>> print(name3['unm']['a'])
123

函数

Python和C语言的差别

c语言定义

int Func(形参);
{
    .....
}

python定义

def Func(形参):
    .....

默认值

def Func(a='1234',b):
    .....

任何数量参数传递

他就定义一个unm形参前面加一个*就会接受然后实参，然后变成元祖

def name(*unm):
    print(unm)

name('a','b','c')

结果

('a', 'b', 'c')

任何数量关键字实参

他就定义一个unm形参前面加一个**就会接受然后键字实参实参，然后变成字典

def name(**unm):
    print(unm)

name(a='a',b='b',c='c')

结果

{'a': 'a', 'b': 'b', 'c': 'c'}

导入模块

方法/函数	作用
import关键字	如导入库
from关键字	指定库里面的函数
as关键字	指定库里面的函数进行改名

import语句

用到import语句如导入库

a.py文件内容

def name(unm):
    print(unm)
def name2(unm):
    print(unm)

a2.py文件内容

import a
a.name('a')
a.name2('b')

输出结果

a
b

from语句

from语句可以给库里面的指定函数到现在的文件里面

a.py文件内容

def name(unm):
    print(unm)
def name2(unm):
    print(unm)

a2.py文件内容

不用在输入.了

a库里面的name和name2函数导入到了a2.py里

from a import  name,name2
name('a')
name2('b')

结果

a
b

as语句

指定库里面的函数进行改名

a.py文件内容

def name(unm):
    print(unm)

a2.py文件内容

下面的 a 库里面的name函数给名指定成a了

from a import  name as a
a('abcd')

结果

abcd

导入库全部函数

语法

from a import *

面向对象

类里面的函数叫做方法

python和PHP的类的定义是差不多的都是属性方法定义就不

php的类的定义

<?php
class 类名{
	//属性
	public $属性名 =值;
	
	//常量
	const 变量名 =值;
	
	//方法
	function 方法名("行参"){
		xxxxx
    }
}

python的类的定义

class 类名:
    
    # 方法
	def 方法名(self,参数):
        # 属性
		self.属性
        
# 创建对象
对象变量=类名()

python的类简单演示

#创建类
class Name:
   # 创建方法
    def metode(self):
        print("abcd")
        
Dog=Name()
Dog.metode()

结果

abcd

self是什么

python里面self是必须有的

解释

我当前记得学习这个的时候研究了很长时间下面就简单解释一下

#创建类
class Name:
    # 创建方法
    def metode(self):
        # 输出self内存地址
        print(id(self))

# 创建对象
Dog=Name()

# 输出对象内存地址
print(id(Dog))

# 调用Name类里面的metode()方法
Dog.metode()

代码

下面id()函数是显示变量内存地址的

下面创建一个Name()类里面有一个metode()方法，

Dog=Name()创建一名字Dog对象

print(id(Dog))输出输出对象内存地址

Dog.metode()调用Name类里面的metode()方法

print(id(self)) 输出self内存地址

结果

可以看见结果是一样的

140682412227600
140682412227600

可以这样理解self就是对象Dog

为什么要有self

下类面代码不用self的问题

下面是没有报错的代码

# 创建类
class Name:
    # 创建方法
    def metode(self):
        # 输出Dog对象里面的Die_Verskil属性
        print(Dog.Die_Verskil)
        
# 创建对象       
Dog=Name()

# 在Dog对象里面添加Die_Verskil属性，他的值是abcde
Dog.Die_Verskil='abcde'
# 调用对象Dog的metode()方法
Dog.metode()

结果

abcde

然后我们叫代码Dog.Die_Verskil='abcde'放到最后

代码

#创建类
class Name:
    # 创建方法
    def metode(self):
        # 输出Dog对象里面的Die_Verskil属性
        print(Dog.Die_Verskil)
        
# 创建对象       
Dog=Name()

# 调用对象Dog的metode()方法
Dog.metode()

# 在Dog对象里面添加Die_Verskil属性，他的值是abcde
Dog.Die_Verskil='abcde'

可以看见就报错了self就是解决这个问题的

__init__方法

这个方法在创建对象的时候自动被调用

演示

# 创建类
class Name:
    
    # 创建对象的时候自动被调用
    def __init__(self):
        print("你不调用我，我也会自己被调用！")
        
# 创建对象       
Dog=Name()

结果

你不调用我，我也会自己被调用！

传参

代码

# 创建类
class Name:
    
    # 创建对象的时候自动被调用
    def __init__(self,a):
    
        # 添加属性默认值
    	self.a=a
    # 创建方法
    def Uitset(self):
    
        # 用self输出属性
        print(self.a)
        
# 创建对象       
Dog=Name("你好！")

# 对象Dog调用Uitset
Dog.Uitset()

__init__方法里面添加一个形参a

任何创新对象的时候传参是“你好”

__init__方法在创建对象的时候被调用然后添加属性self.a值是传的“你好”

结果

你好！

添加属性默认值

代码

# 创建类
class Name:
    
    # 创建对象的时候自动被调用
    def __init__(self,die="我是默认值"):
        # 添加属性默认值
    	self.die=die
    # 创建方法
    def Uitset(self):
        # 用self输出属性
        print(self.die)
# 创建对象       
Dog=Name()

# 对象Dog调用Uitset
Dog.Uitset()

在__init__方法里添加self.die属性他值是"我是默认值"

结果

我是默认值

继承

比如有两个类，a类和b类里面的有一个不一样，在写代码的时候里面都要写重复的麻烦，我们就可以用继承，类里面用其他的类，

比如b类调用（继承）a类，这个a类就是父类b类就是子类

b类继承a类会拥有a类的全部方法和属性

继承的格式

class 类名(父类名):
    .....

简单演示

下面Name2(Name1)类里面有Name1类，就是继承成了Name1全部的方法和属性，

Name2就有一个Uitset方法但是继承了Name1类的全部属性方法就可以输出abc

# 创建类
class Name1:
	# 创建Long方法
    def Long(self):
        print('a')
	# 创建Year方法
    def Year(self):
        print('b')

# 创建类
class Name2(Name1):
    
    
	# 创建Uitset方法
    def Uitset(self):
        # 用self输出属性
        print('c')
# Name2创建对象       
Dog=Name2()

# 对象Dog调用
Dog.Long()
Dog.Year()
Dog.Uitset()

结果

a
b
c

super()对父类方法扩充

super()可以调用父类的方法 注意是方法

方法/函数	作用
super()函数	函数是用于调用父类(超类)的一个方法

代码

下面在18行调用调用Name2类的Uitset()方法

Uitset()方法方法里面用super()调用Name1父类iong()方法

# 创建类
class Name1:
	# 创建方法
    def iong(self):
        print('abc')
# 创建类继承Name1父类
class Name2(Name1):
    
    # 创建方法
    def Uitset(self):
        # 用super()调用Name1父类iong()方法
        super().iong()
        
# 创建对象       
Dog=Name2()

# 调用Name2类的Uitset()方法
Dog.Uitset()

结果

abc

演示复杂一点的

下面这个代码可能比较复杂一点

19行创建对象，给Name2类传一个abc实参，然后会传给Name2子类的__init__的a的形参

然后super()就会和Name1父类的__init__连接起来，然后Name2子类有一个a的传给Name1父类的__init__里面的a

22行就调用父类的iong的方法

# 创建类
class Name1:
	# 创建对象的时候自动被调用
    def __init__(self,a):
        self.a=a
    
    # 创建方法   
    def iong(self):
        print(self.a)
# 创建类继承Name1父类
class Name2(Name1):
    
    # 创建方法,传一个形参
    def __init__(self,a):
        # 用super()调用Name1父类__init__方法
        super().__init__(a)
        
# 创建对象       
Dog=Name2('abc')

# 调用Name2类的Name1父类的iong()方法
Dog.iong()

结果

abc

重新类的方法

很简单就是在子类里面创建一个给父类名一样的方法，就会输出子类的新创建的方法，不会输出父类那个和子类同名的方法

代码

# 创建类
class Name1:

    # 创建方法   
    def Re(self):
        print("123")
# 创建类继承Name1父类
class Name2(Name1):
    
    # 创建方法，和父类的方法一样
    def Re(self):
        print("abc")
# 创建对象       
Dog=Name2()

# 调用Name2类的Re()方法
Dog.Re()

结果

可以看见这个就是重新类的方法

abc

导入类

单类导入

代码

a2.py文件

# 创建类
class Name1:

    # 创建方法   
    def Iong(self):
        print("123")

# 创建类
class Name2():
    
    # 创建方法  
    def Re(self):
        print("abc")

a.py文件

# 打开a2模块，到a2里面的Name1类
from  a2 import Name1

# 创建对象
cat=Name1()
# 输出Name1()里面的Iong()方法
cat.Iong()

结果

123

导入多个类

导入多个类和导入单个类差

a2.py文件

# 创建类
class Name1:

    # 创建方法   
    def Iong(self):
        print("123")

# 创建类
class Name2():
    
    # 创建方法  
    def Re(self):
        print("abc")

a.py文件

# 打开a2模块，到a2里面的Name1类和Name2类
from  a2 import Name1,Name2

# 创建对象
cat1=Name1()
cat2=Name2()

# 输出Name1()里面的Iong()方法
cat1.Iong()
# 输出Name2里面的Re()方法
cat2.Re()

结果

123
abc

导入全部类

这个我就不演示了

他的格式

from  a2 import *

文件操作

文件操作常用到的函数

方法/函数	作用
open()函数	打开文件，并返回文件的对象
close()方法	关闭文件
read()方法	读取整个文件，将文件内容放到一个字符串变量中
readline()方法	读取一行，然后他会移动到下一行
write() 函数	可以向文件中写入指定内容

open()打开文件

打开文件，并返回文件的对象,如果没有文件则返回一个出现异常

open()函数的格式

open("文件名",'打开方式，如果不添加默认是r')

下面是打开类型

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

比如

下面这个就是往a.txt写

a=open("a.txt",'w')

close()关闭文件

关闭文件

格式

# 打开文件
a=open("a.txt",'w')
.....
# 关闭文件
a.close()

read()读取文件

读取整个文件，将文件内容放到一个字符串变量中

a.txt文件内容

aaaaa
bbbbb
ccccc
ddddd
eeeee

read.py文件内容

# 打开文件不添加打开方式默认是r
a=open('a.txt')

# 读取文件内容
b=a.read()

# 输出文件内容
print(b)

# 关闭文件
a.close()

结果

aaaaa
bbbbb
ccccc
ddddd
eeeee

readline()读取一行

读取一行，然后他会移动到下一行

a.txt文件内容

aaaaa
bbbbb
ccccc
ddddd
eeeee

read.py文件内容

# 打开文件不添加打开方式默认是r
a=open('/home/zss/杂东西/a.txt')

# 读取一行，然后他会移动到下一行
b=a.readline()
# 输出
print(b)

# 关闭文件
a.close()

结果

aaaaa

读取文件的全部内容

a.txt文件内容

aaaaa
bbbbb
ccccc
ddddd
eeeee

read.py文件内容

# 打开文件不添加打开方式默认是r
a=open('a.txt')

# 死循环
while True:

    # 读取一行，然后他会移动到下一行
    b=a.readline()

    # 判断b是否等于假，等于假然后not取反就等于真
    # not与逻辑运算结果相反
    if not b:
        break
    
    # 输出
    print(b)

# 关闭文件
a.close()

结果

aaaaa

bbbbb

ccccc

ddddd

eeeee

write()写文件

要以写入的方式要添添加w写入模式，a附加模式（就是在文件最后添加），然后你想读和写可以用r+

如果我们写的文件不存在w会创建一个文件，然后这个文件存在w会清除里面的内容

read.py文件内容

# 写入文件的方式打开
a=open('a.txt',"w")

# 向a.txt文件里面写入abc
a.write("abc")


# 关闭文件
a.close()

看一下a.txt文件

os模块

应为OS模块文件太多了我就列出几个常用的

os模块常用方法	相应的作用
os.getcwd()	返回当前工作目录
os.listdir(文件夹名)	目录列表
os.mkdir(文件夹名)	创建文件，只能创建一个单层文件，而不能嵌套创建，若文件夹存在则会抛出异常
os.makedirs(文件夹名/文件夹名)	创建多层目录 ，可以嵌套创建
os.rmdir(文件夹名)	删除单层目录，遇见目录非空时则会抛出异常
os.rename(文件名,文件名)	修改文件名
我下面就随便演示一个

代码

# 导入os模块
import os

# 创建文件
a=os.mkdir("aaaaaaa")  

结果

异常

在python如果代码出差他就会结束代码，我们要加上异常他还回正常执行后面的代码

简单捕获异常

格式

try:
    # 正常的语句
except:
    # 正常的语句错误就会执行这个

演示

print(a)
print("被执行了！")

结果可以看见报错了，应为没有a这个变量，后面的代码就不会在执行了

Traceback (most recent call last):
  File "/home/zss/杂东西/a.py", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

我们用异常来处理

try:
    print(a)
except:
    print("上面有错误！")
    
print("被执行了！")

结果

上面有错误！
被执行了！

指定错误类型处理

查看错误类型

代码

print(a)
print("被执行了！")

结果可以看见报错了，应为没有a这个变量，后面的代码就不会在执行了

Traceback (most recent call last):
  File "/home/zss/杂东西/a.py", line 1, in <module>
    print(a)
NameError: name 'a' is not defined

NameError就是错误类型

指定错误类型处理

格式

try:
    # 正常的语句
except 指定的错误类型:
    # 正常的语句错误就会执行这个

演示

下面代码没有定义a变量就会报错NameError类型的错误

try:
    print(a)
except NameError:
    print("上面有错误！")

print("被执行了！")

结果

上面有错误！
被执行了！

捕获未知错误

格式

下面如果正常的语句错误就会被捕获然后，会吧错误信息给下面那个变量名

try:
    # 正常的语句
except Exception as 变量名:
    # 正常的语句错误就会执行这个

演示

如果上面有错误就会吧错误信息给b那个变量

try:
    print(a)
except Exception as b:
    print("未知错误："+str(b))

结果

未知错误：name 'a' is not defined

其他异常语法

else没有错误的时候执行

finally什么时候都会执行

演示有错误

代码

下面的a变量没有定义

try:
    print(a)
except Exception as b:
    print("未知错误："+str(b))
else:
    print("上面没有错误！")
finally:
    print("什么时候都会执行！")

结果

未知错误：name 'a' is not defined
什么时候都会执行！

演示没有错误

代码

try:
    a="aaaa"
    print(a)
except Exception as b:
    print("未知错误："+str(b))
else:
    print("上面没有错误！")
finally:
    print("什么时候都会执行！")

结果

aaaa
上面没有错误！
什么时候都会执行！

raise关键字用于引发异常，您可以定义要引发的错误类型以及要向用户打印的文本

代码，他就会指定你报的错误

>>> raise StopIteration
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

常用的函数

split()分隔

他就是分割用的一个方法，下面这样你应该就能看懂了

1. 演示1

   下面这个用的:进行分割的

   >>> a='dasdasdasdas:122:@#@$@'
   >>> print(a.split(':'))  # 以:来分
   ['dasdasdasdas', '122', '@#@$@']

2. 演示2

   下面这个用的|进行分割的

   >>> a='dasdasdasdas|@#@$@|12122'
   >>> print(a.split('|'))
   ['dasdasdasdas', '@#@$@', '12122']

3. 演示3

   下面这个用的==进行分割的，然后加一个1他就会输出二个参数

   >>> a='dasdasdasdas==@#@$@==12122'
   >>> print(a.split('==',1))
   ['dasdasdasdas', '@#@$@']

   sys标准库使用

isinstance()函数

isinstance()函数来判断一个对象是否是一个已知的类型

sinstance() 与 type() 区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

他的格式

isinstance(object, classinfo)

参数	作用
object	实例对象
classinfo	可以是直接或间接类名、基本类型或者由它们组成的元组

a=1111
print(isinstance(a,int))

结果

True

zip函数

zip() 是内置函数，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。

常使用的方式

a=[1,2,3]
b=[4,5,6]

for i,x in zip(a,b):
    print(i)
    print(x)

结果

1
4
2
5
3
6

我们可以叫zip对象强转成一个列表用list()函数

代码

a=[1,2,3]
b=[4,5,6]

print(list(zip(a,b)))

结果

[(1, 4), (2, 5), (3, 6)]

如果里面内容长度不一样他会按照最短的那个了匹配

a=[1,2,3,4]
b=[4,5]

print(list(zip(a,b)))

结果

[(1, 4), (2, 5)]

join()方法

方法返回一个被子字符串连接的字符串

a=['1','2','3','4']

print('-'.join(a))

结果

1-2-3-4

用无的字符连接

a=['1','2','3','4']

print(''.join(a))

结果

1234