python学习随笔

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 包名.模块名