1,python里面的数据类型
a,int型(不可变)
b,str型(不可变)
c,list型(可变)
d,tuple型(不可变)
e,set型(可变)
f,dict型(可变)
import sys
#int
ge=1
print(type(ge))
#字符型
CHAR='c'
print(type(CHAR))
#列表
ll=[10,'name']
print(type(ll))
#元组
d=(1,2,3)
print(type(d))
#集合
collec={10,20,30}
print(type(collec))
#字典
NB={'name':'kk','age':10}
print(type(NB))
2,格式化输出
print()//自带\n
占位符
print(f’{name},{age}')试用于python3.6以上
print(‘output text’,end=“\n”) print的默认形式
3,标准化输入input,用input输入的函数默认为字符串
4,python里面的强转
5,python里面的算数运算符
6,多变量赋值
eg: a,b,c=10,8,‘str’
7,逻辑运算符
and,or,not
8,条件判断与循环
import sys
name="NB"
age=100
n=10
while n>0:
if n>5:
print(f'{name},{age}')
if n>8:
while age>0:
print(f'{n}')
age-=1
n-=1
str1='hello python'
str2=['123',56]
for i in str1:
print(f'{i}')
for i in str2:
print(f'{i}')
while和else连用
i=10
while i>5:
i-=1
else:
print("finish")
同样for和else也一样
字符串中的切片操作
语法:序列[开始位置下标:结束位置下标:步长]
注:不包含结束位置的下标对应的数据,正负均可。
步长为隔几格取数出来。
9,字符串常用的操作方法
字符串是不可改变类型
查找字符串
find(),index()(如果找不到会发生错误)rfind()和rindex()(找不到也会报错)带r代表从右查找
统计子串字数
count
修改字符串
replace()#不会修改原来的数据
split()#会返回一个列表
join()#拼接列表里面的字符串
capitalize()#将字符串的首字母改为大写
title():将字符串中的每一个子串的首字母改为大写
upper()小写变大写
lower()大写变小写
lstrip()删除左侧空白字符
rstrip()删除右侧空白字符
strip()删除两侧空白字符
startswith()检查字符串是否以指定子串开头。是返回true否返回false
isalpha()判断这个字符串是否全是字符
isdigit()判断字符串是否全为数字
eg:
str="strstr strstrabcdefghijk"
posi=str.find('abc')
print(str.index('cde'))
print(posi)
print(str.count('str'))
print(str.rindex('cde'))
print(str.find('abc'))
print(str.count('str'))
print(str.replace('str','abc',3))#不会改变原有字符串
new_list=str.split('s')
print(new_list)
str3='...'.join(new_list)
print(str3)
str4=str.capitalize()
print(str4)
str5=str.title()
print(str5)
str6=str.upper()
print(str6)
print(str.startswith('str'))
10,列表常用操作
下标法
查询方法
index()
count()
len()求长度
in与not in查询指定数据是否在列表中
列表增加数据
append()追加到尾部
extend()追加到尾部,并将追加到的序列拆开
insert()任意位置追加
删除
del删除列表
clear清空
remove删除指定数据
pop删除指定位置
排序
sort()按升序排列
reverse()转序
复制函数
copy()
也可以直接等于
data=[123,'oio']
print(data[0])
print(data[1])
print(data.index(123))
print(data.count('op'))
print(len(data))
data.append("aaaa")
print(data)
data.extend("lol")
print(data)
data.insert(1,90)
print(data)
print(data)
i=0
while i<len(data):
print(data[i])
i+=1
for i in data:
print(i)
data.pop(0)
data.remove('oio')#删除指定数据
data1=data
print(data1)
data3=[[11,22,33],['po',99]]
print(data3)
i=0
j=0
print(data3[i][j])
while i<len(data3):
while j<len(data3):
print(data3[i][j])
j += 1
i += 1
11,元组(不支持修改)
多个数据元组
t1=(1,2,3)
单个数据元组
t2=(1,)
其他方法和上面数据类型一样
元组中的列表可以修改
12,字典(数据必须是键值对)(为可变类型)
删除del()
清空clear()
用下标就可以查找[],或者get()方法
values()得到键值返回迭代器
iterms()得到所有的键值对,返回一个迭代器
keys()查找key返回一个可迭代对象
13,集合
创建空集合只能用set()
集合数据具有唯一性
增加数据add()
增加数据(序列)update()
移除数据remove()(若不存在则报错)
丢弃数据discard()(不存在也不会报错)
pop()(随机删除)
查找in not in
13,公共方法
+:合并字符串、列表、元组
*:复制字符串、列表、元组
len():计算容器中元素的个数
del():删除一个元素
max():求最大值
min():求最小值
range()生成从start到end的数字,步长为step,供for循环使用
enumerate()用于遍历一个数据对象再将他组合成一个索引序列
14,类型转换
强转tuple(),list(),set()
15,推导式
列表变为字典
lis1=[1,2,3,4,5]
lis2=['a','b','c','d','e']
dic={lis1[i]:lis2[i] for i in range(len(lis1))}
print(dic)
列表推导式
[xx for xx in range()]
字典推导式
{xx1:xx2 for … in …}
集合推导式
{xx for xx in …}
16,函数
关键字def
先定义在调用
函数返回多个值时,返回的数据类型是元组
关键字传参是通过形参来传递的
lis1=[1,2,3,4,5]
lis2=['a','b','c','d','e']
dic={lis1[i]:lis2[i] for i in range(len(lis1))}
print(dic)
def test2(b):
print(b)
def test1(a):
test2(a)
a.append(10)
return a,1
print(list(test1(lis1)))
lis3=list(test1(lis1))
print(lis3)
print(lis3[0][1])
**17,**缺省参数,函数形参有一个或几个是默认值,如果传入参数时就改变这个默认值
def func(a,b=3):
print(f'{b},{a}')
func('9999',8)
不定长之位置参数(也就是说传入参数不知道多少个,返回元组)
def user_info(*args):
print(args)
user_info('ll',90)
user_info()
不定长之关键字参数(返回一个字典)
def func1(**kwarg):
print(kwarg)
func1(key=60,s='name')
18,元组拆包
def func2():
return 1,2
num1,num2=func2()
print(num1)
print(num2)
字典拆包
dic={'key':60,'s':'name'}
a,b=dic
print(a)
print(b)
print(dic[a])
print(dic[b])
**19,**引用可以用id来判断两个变量是否是引用同一个变量
20,递归
def jie(k):
if k==1:
return k
elif k!=1:
k-=1
return k*jie(k)
21,lambda语法
如果一个函数有一个返回值,并且只有一句代码,可以使用lambda简化
lambda 参数列表:表达式
注意
lambda表达式的参数可有可无,函数的参数在lambda表达式中完全适用
lambda表达式能接收任何数量的参数但只能返回一个表达式的值
fn3=lambda a,b:a+b
print(fn3)#函数地址
print(fn3(1,1))#函数值
可变参数*arg使用lambda
fn1=lambda *args:args
print(fn1(10,20,30))
可变参数**kwargs
fn2=lambda **argv:argv
print(fn2(name='python',age=10))
带判断的lambda
fn3=lambda a,b:a if a>b else b
print(fn3(10,20))
stu=[
{'name':'ll','age':10},
{'name':'ll','age':20}
]
stu.sort(key=lambda x:x['name'],reverse=True)
print(stu)
22,高阶函数
定义:把函数作为参数传入。(类似于C语言中的函数指针)
def add(a,b):
return abs(a)+abs(b)
print(add(10,-10))
def add(a,b):
return abs(a)+abs(b)
def sum(a,b,f):
return f(a,b)+f(a,b)
print(sum(5,-5,add))
内置高阶函数
map(func,lst),将传入的函数变量func作用到lst变量的每一个元素中,并将结果组成新的列表返回
lis=[1,2,3,4,5]
def func(x):
return x**2
result=map(func,lis)
print(result)#打印的地址
print(list(result))
reduce(func,lst),其中func必须有两个参数,每次func计算的结果和序列的下一个元素做累加计算
import functools
lis=[1,2,3,4,5]
def func(a,b):
return a+b
result=functools.reduce(func,lis)
print(result)
filter(func,lst)函数用于过滤序列,过滤掉不符合条件的元素,返回一个filter对象。如果要转换为列表,可以用list()转换
lis=[1,2,3,4,5]
def func(a):
return a%2==0
result=filter(func,lis)
print(list(result))
文件操作
a,基本api:
1,open(name,mode)返回文件对象
2,read(num)num读取多长
3,write(内容)
4,close()
5,readlines()读取每一行,把每一行读出来变成的是列表
6,readline()一次读取一行内容
7,seek(偏移量,起始位置)移动指针位置
b,os模块中学习
api,os.rename(targetfile,new_file)
os.remove(目标文件名)
文件夹api
os.mkdir()创建目录
os.rmdir()删除目录
os.getcwd()获取当前目录
os.chdir(目录)改变默认目录
os.listdir(目录)获取目录列表
面向对象操作
特征即是属性
行为就是方法
关键字
class 类名():
self表示该对象类似于C++中的this
_init_有下划线的函数叫特殊的方法
init()类似于构造函数
访问类里面的变量一定要加self和其他数据区分
str()默认打印对象的内存地址,如果自己实现了,那么就可以打印对象时就能打印出自己实现的值
del()类似于析构函数
class washer():
def __init__(self):
self.l=100
print(self.l)
self.l = 80
def __str__(self):
return 'll'
def __del__(self):
self.l=50
print(self.l)
rev=washer()
print(rev)
2,继承
a,继承:pass是可以不写子类的参数,沿用父类的方法,如果写了则采用自身的方法,继承多个对象时,若写pass那么继承的析构和构造按第一个继承的父类继承。若需要重写父类方法直接重写就可以了。子类和父类有同名方法,默认使用子类的方法。为了保证父类的方法必须在调用前,先调用自己的初始化。
b,运用super方法调用父类的方法
语法:super(当前类名,self).函数()#有参数super
super().函数()#无参数super
在使用super时都要调用父类的__init__()函数
class base():
def __init__(self):
self.l=100
print(self.l)
self.l = 80
def __str__(self):
return 'll'
def __del__(self):
self.l=50
print(self.l)
def makething(self):
print("base")
class a():
def __init__(self):
self.l = 120
print(self.l)
self.l = 90
def __str__(self):
return 'll'
def __del__(self):
self.l = 1000
print(self.l)
class b(base,a):
def __init__(self):
self.k = 120
print(self.k)
self.k = 90
def __str__(self):
return 'll'
def __del__(self):
self.k = 1000
print(self.k)
def makething(self):
print("b")
def makething_make(self):#调用父类的方法
base.__init__(self)
base.makething(self)
c=b()
c.makething()
c.makething_make()
3,定义私有属性的方法
在需要定义的方法和属性前面加两个下划线
import sys
class base:
def __init__(self):
self.value=100
self.__value=2000
def __del__(self):
print(self.value)
print(self.__value)
def __func(self):#私有方法
self.value=10000
self.__value=555#私有属性
print(self.value)
print(self.__value)
def pri(self):
self.__func()
class a(base):
pass
object=a()
object.pri()
4,类属性就是用类名去访问他本身的属性和方法
a,类属性只能通过类对象修改,不能让实例化对象修改
b,当方法中需要使用类对象(如访问私有类属性等)时,定义类方法,类方法一般和类属性配合使用。关键字类方法(@classmethod)
class dog(object):
tooth=100
print(dog.tooth)
class dog(object):
__tooth=100
@classmethod
def get_tooth(cls):
return cls.__tooth
wa=dog()
print(wa.get_tooth())
注意类里面需要有object,这里的object是所有类的父类规定了类的构造。
5,静态方法特点
需要通过装饰器@staticmethod来进行修饰,静态方法既不需要传递类对象也不需要传递实例对象
静态方法也能通过实例对象和类对象去访问。
取消不需要的参数传递,有利于减少不必要的内存占用和性能消耗。
class dog(object):
__tooth=100
@classmethod
def get_tooth(cls):
return cls.__tooth
@staticmethod
def prit():
print('this is staticmethod')
wa=dog()
print(wa.get_tooth())
wa.prit()
异常
定义
当检测到一个错误时,解释器就无法继续执行了,反而出现了一些错误的提示,这就是所谓的异常。
异常的写法
try:
可能发生的错误代码
except :
如果出现异常执行的代码
try:
w=open('tet.txt','r')
except:
w=open('tet.txt','w')
捕获异常描述信息
try:
print(num)
except (NameError,ZeroDivisionError) as result:
print(result)
捕获所有异常信息
try:
print(num)
except Exception as result:
print(result)
用else处理没有异常做的东西,用finally不管是否有异常都会执行
try:
print(num)
except Exception as result:
print(result)
else:
print('not error')
finally:
print('end')
自定义异常类
class short_input(Exception):
def __init__(self,length,min_len):
self.length = length
self.min_len = min_len
def __str__(self):
return f'密码长度不够'
def main():
try:
password=input('please input password')
if len(password) < 3 :
raise short_input(len(password),3)#返回该类的__str__()的信息
except Exception as result:
print(result)
else:
print('finish')
main()
模块
1,导入模块的方式
import 模块名
from 模块名import功能名
from模块名import*
import模块名as别名
from模块名import功能名as别名
2,引用模块的寻找路径
a,当前路径
b,如果不在当前路径,python则搜索在shell变量PYTHONPATH下的每一个目录
3,如果找不到,python会查看默认路径。unix一般会查看/usr/local/lib/python/
注意:不能和已有的模块重复
__all__列表
如果一个模块文件中有__all__变量,当使用from xxx import * 导入时,只能导入这个列表中的元素
__all__=['myprint']
def myprint(a,b):
return a+b
def test():
print('test')
包
包将有联系的模块组织在一起,即放到同一个文件夹下,并且在这个文件夹下创建一个名字为__init__.py文件,那么这个文件夹就叫做包
导入包
import 包名.模块名