python小记

面向对象解释型语言

image.png
https://www.tiobe.com/tiobe-index/
规范的缩进
解释性:
一行一行的读取 执行
可以在第一行声明解释器
#!/+python命令的目录+python

然后写代码
声明可执行权限
chmod u+x python文件名字.py
执行
./python文件名字.py

可以设置vim
显示行号
和缩进的格数

python 注释
一行#
一块```` ```
定义一个main函数
def main():
ascll码
127 个字符
找8位 就一个字节就能对字符进行编码
中文两个字节
才能存
unicode 编码
全球的语言4个字节
可以在代码第一行声明编码
8-bit Unicode Transformation Format 就是utf - 8
py 变量的值是什么类型 就是什么类型
a=1
a是栈里的引用
1是堆里的值

变量

看a的类型
type(a);
str="hello"
x,y=11,22
z=True
trueT大写
字符串可以""   /  ' '
None  大写!  是一个特殊的空值  防止空指针 在堆内存中有值

标识符

print("aa","bb","cc")
print(222+333)
print("我的年龄%d"%a)
print("我的年龄%d"%(a+b))
print("我的年龄%d,名字是%s"%(a+b,name))
%s可以所有的类型 
int 也可以

print("hehe%4d"%a)
4表示%d占几位 默认用空格填充
print("hehe%04d"%a)
4表示%d占几位 用o填充
  w=3.1415926
print("圆周率%.6f"%w) 
百分号 表示占位符
%%第一个表示%转义

输入

inn = input("请输入姓名")
print(inn)
把输入当成字符串
转换 aa=int(inn)

符号

**
取幂
print(7/3)
print(7//3)
print(7%3)
2.3333333333333335
2
1

导包
pip install matplotlib ,pip install numpy

a = 4
m = "lin"
c = input("shuru")
if a >= 4 and m == "lin":
    print("为后来的撒阿飞")
---------------------------------------
a = 4
m = "lin"
if a < 4 and m == "lin":
    print("为后来的撒阿飞")
elif a >= 4 or m == "":
    print("shenme")
---------------------------------
a = 4
m = "lin"
if a < 4 and m == "lin":
    print("为后来的撒阿飞")
elif a >= 4 or m == "":
    print("shenme")
------------------------------------
还能加
elif not  a !=4:
    pass
    print("asdgfa")

循环

i = 1
sum =0
while i<100 :
    sum=sum+i
    i=i+1
print(sum)
---------------------------------------------
i = 1
sum =0
while i<=100 :
    if i%2==0:
        sum=sum+i
    else:
        pass
    i=i+1
print(sum)

---------------------------------------
n= int(input("请输入行数"))
i=0
while  i <=n:
    j=0
    while j < i :
        print(" ",end="")
        j = j+1
    j=n-i
    while j > 0 :
        print("* ",end="")
        j =j-1
    i=i+1
    print("\n")

输出:
请输入行数4
* * * * 
 * * * 
  * * 
   * 

默认 
print (" ") 结束自动换行 
下面可以取消换行
应该是以""结束吧
  print("* ",end="")
打印回车
 print("\n")

for循环

• 循环次数
• 每次循环干什么
• 变量怎么变化

n=0
for i in range(1,10):
    n=n+i
    print(i)
print(n)
for i in ["hhh","asdf","fsdgf"]:
    print(i)

1
2
3
4
5
6
7
8
9
45
hhh
asdf
fsdgf

break continue
字符串

mm="fsadf"
len(mm)是长度 
name[0]
f
name[-1]
f
截取
截取包头不包尾
[开始:结束:步长]
步长:
是下标变换的规则
name ="ashdgadafl"
bb=name[0:3]
print(bb)
----------------------------------
name ="ashdgadafl"
bb=name[0::2]
print(bb)
输出:
ahgdf
倒序
name ="ashdgadafl"
bb=name[-1::-1]
print(bb)

``
------------------
name ="ashdgadafl"
find = name.find("sh")
print(find)
输出:
1
---------------------------------------
name ="ashshafl"
find = name.rfind("sh")
print(find)
输出 :3

字符串的函数方法

index
 和find 一样
  只不过找不到报错
   find找不到 返回-1
count 统计某个字符串出现的次数
replace("aa","bb")
split(" ",2) 2表示最多分隔的段数 2分成3段
partition("bb") 截取 但是bb还是当成一个片段保留
capitalize()
首字母大写
title 每个字母首字母大写
endswith(".txt") 
statarts.with(" ")
lower
upper
对其方式
不够空格填充
ljust(50)
rjust(50)
center(50)
去首尾空格
strip() (在java中是trim())
lstrip()
rstrip()
以换行作为分割符  \n
splitlines()
判断
isalpha
isdigit
isalnum
isspace
join

name =["afa","asdf","forrad"]
join = "_".join(name)
print(join)
输出:

afa_asdf_forrad

注:split() 默认以空格 制表符 \n 分开

列表有序可重复的集合

names[100,33,"dafwe"]
常用方法
添加插入合并
name =["afa","asdf","forrad"]
name2=["sd","rr"]
name.append("chanru")
name.insert(0,"sdf")
name.extend(name2)
计数
count = name.count("afa")
in和not in
name =[100,"afa","asdf","forrad"]
100 in name;
in_name = "afa" not in name
删除
name =[100,"afa","asdf","forrad"]
del  name[1]
name.pop()
name.remove("asdf")
print(name)

逆置
reverse()
排序
sort()

元组

定义后不能修改 不能增加

name=('aa','bb','cc')
name=('aa','bb','cc',name)
name里面能修改 name 不能修改


rang(1,10) 返回的是一个列表
for i in range(1,10)
python 3 里面是懒加载
 python 里的整数不限大小

字典

无序 没下标
就是map

d={"lin":89,"jin":34}
print(d)
print(d["lin"]) 没有会报错
d.get("lin")  没有返回空
d["bo"]=23
print(d)
del d["bo"]

函数

def 函数名():
    代码
def main():
    print("人")
main()

def main(d,d):
    print("人",d)
    print(type(d))
main("sdagd")
输出
人 sdagd
<class 'str'>


def main(d,dd):
    return d+dd

main1 = main(3, 4)
print(main1)
输出7

匿名函数

fun= lambda a, b: a + b
:后面是一个表达式
把函数当成一个变量
print(fun(2,3))
输出5

把函数当成参数传入
def test(a,b,c):
    return c(a,b)
print(test(2,3,lambda d,e:d+e))
 
排序和数据结构
mm=[{"name":"lin","age":13},{"name":"jin","age":14}]
mm.sort(key=lambda x:x["name"],reverse=True)
print(mm)

文件操作

f=open("D:\\",'w')
f.close
后面是文件访问模式
默认就是r
w r a 追加  ......
文本文件用上面
二进制文件用  rb 和wb 
如果是w 如果文件不存在就会创建一个新的文件
文本文件的定义 能直接通过gbk 等常用编码


f=open("text.txt",'r')
# f.write("shema af sdfd\tsagf")
read = f.read(4)
print(read)
f.close()
读取4个字节

当前指针指向的位置
tell = f.tell()

os

import os
name = os.name
print(name)

面向对象

class stu:
    name="df"
    age ="14"
#第一个参数必须是self
    def name (self):
        print("saaf")
        return "argfda"


s = stu()
print(s.name())

初始化方法  封装数据
之前还有一个___new__()方法构造对象


class stu:
    def __init__(self):
        self.name="zhang"
        self.age=13
        print("self")
s = stu()
print(s.age,s.name)

输出
self
13 zhang

------------------------------------
初始化传参
class stu:
    def __init__(self,name,age,weith):
        self.name=name
        self.age=age
        print("self")
s = stu("jin",15,134)
print(s.age,s.name)


tostring
-----------------------------------
class stu:
    def __init__(self,name,age,weith):
        self.name=name
        self.age=age
        print("self")

    def __str__(self):
     return  "+++++%s%s"%(self.name,self.age)
s = stu("jin",15,134)
print(s.age,s.name)
print(s)

py里
__xxx__
是有特殊功能的方法

继承

保护对象
属性之前加了 "__"就不能在类外面访问
就是 private
方法也是一样
class stu:
    def __init__(self,name,age,weith):
        if len(name)>6:
            self.__name = name
        else:
            print("密码不符合规定")
        self.age=age
    def get__name(self):
        return self.__name

s = stu("jgdfsgsgrzfxdfhy",15,134)
print("%s    %s "%(s.age,s.name))
# print("%s    %s "%(s.age,s.get__name()))
-----------------------------------------------------------------------
__del__()方法
销毁对象回调的方法
class stu:
    def __del__(self):
        print("del---------")


s = stu()
del s
print("============")
输出:
del---------
============


要等到对象的引用为0才回del 
否则   对象引用 -1

报错
TypeError: HH() takes 0 positional arguments but 1 was given
就是写方法没写self
继承
class peo:
    def HH (self):
        print("我是人")
class stu(peo):
    def __del__(self):
        print("del---------")
s = stu()
s.HH()
------------------------------------------和java 的构造方法有点区别
class peo:
    def __init__(self,a):
        self.age=a
        print(a)
    def HH (self):
        print("我是人")
class stu(peo):
    def __del__(self):
        print("del---------")
s = stu(13)-----这里调用的是peo的
s.HH()

多继承

和顺序有关

class peo:
    def HH (self):
        print("我是人")

class peo2:
    def HH (self):
        print("我是人2")

class stu(peo,peo2):
    def HH(self):
        print("del---------")
s = stu()
s.HH()
print(stu.__mro__)

del---------
(<class '__main__.stu'>, <class '__main__.peo'>, 
<class '__main__.peo2'>, <class 'object'>)

重写只要方法名字相同

和参数没关系

调用父类的方法
super().XX方法

多态

弱类型的语言 python 没啥多态效果

类属性

类似static
class peo(object):
    name="ren"
    __age=24 私有
----------------------------------------
class peo(object):
    name="ren"
    __age=24
    def __init__(self):
        self.name="ennn"
        self.__age=53

p = peo()
name = p.name
print(name)

优先是init 里的局部变量
然后是才是类变量
类属性
的修改和删除自能通过类名来修改
通过对象名和类名都能使用

类方法

    @classmethod
    def sdf(cls):
        print("class")
        return "he"

print(peo.sdf())

静态方法

class peo(object):
    @staticmethod
    def asdf():
        print("saf")
print(peo.asdf())