my kernel of python3.9

知识网络图

杂点语法细节

注释

# 这是一条注释

'''
这也是一条注释
'''

单行和多行问题

# 变量运算 反斜杠代表换行连接
sumups = he + \
         she + \
         me

# 字符串定义 三个代表换行连接
name = 'poilzero'
name = '''poil
zero'''


# 一行多语句用半角字符分号“;”连接
myobject = 'boyfriend';myname = 'poilzero'

不区分单双引号

"""
这还是一条注释
"""
# 上面等价下面（下同）
'''
这也是一条注释
'''
# 分割线--------------------------------
names = "poilzero"
names = 'poilzero' # 上下等价

变量花样赋值

# 执行从右到左逐一赋值
blogname = internetname = name = 'poilzero'
# 一一对应赋值
name,age,height='poilzero','18years','183cm'

文件编码设置

python3默认以utf-8编码格式存储和解析源码，但是也可以指定对应的编码格式来满足不同需要

# 默认指定（不写的话等价写了这一行）
# -*- coding: utf-8 -*-
# 指定unicode
# -*- coding: unicode -*-

字符串内置处理

切片语法

str = 'poilzero'
# str[起始位数:截止位数（若省略前面的冒号则为仅选择一位）:间隔位数（默认为1,需要省略前面的冒号）]
# 截止位数：切片函数的左右区间是【左闭右开】的 所以0-2 即选中0 1位
print(str[0:3])# poi
# 截止位数：如果不写截至位数（写了前面的冒号）则 默认截至到最后一位
print(str[2:]) # 从第三位开始到结尾 ilzero
print(str[2])  # 获取字符串第三位的字符 i
# 截止位数：负数代表倒数第几位
print(str[2:-1])

两组小语法

str = 'poilzero'
# 重复输出 和 连接
print(str * 99)
print(str + 'yes')
# 转义 和 反转义（原样输出）
str = str + '\n' + 'yes'
print(str)
print(r str)

一些新的运算符

三组专有的运算符：**//:=

• a**b代表a的b次方

• a//b代表a/b后取整，比如11除以4等于2余3，这里的2和3可以分别表示为

  • 11//4即2
  • 11%4即3

• :=因为长得像海象，被称为海象运算符。用于简写代码oh yeah

  # 由于实现特性的缘故，python的=赋值仅仅是赋值，不会有临时值，因此不能这么写
  name = "eel"
  if (n=len(name)) == 3: # 此处编译器报错
      print("yes")
  # 但要想实现相同的功能怎么办呢？对，使用海象运算符
  name = "eel"
  if (n:=len(name)) == 3:
      print("yes")
  # 效果是与如下这段代码等价
  name = "eel"
  n = len(name)
  if n == 3 :
      print("yes")

身份运算符

在python中数据类型也是对象

在python中同一进程赋的相同的数值都会指向同一地址

id(objective)：获取对象在内存中的地址，因为内存地址不能同时被占用，因此可以作为对象的唯一标识，即id

• a is b等价于id(a) == id(b)，is not同理

成员运算符

判断某个值在序列中是否存在

if 115 in range(1000):
    print('exist')
else:
    print('unexist')
# 上下等价
if 115 not in range(1000):
    print('unexist')
else:
    print('exist')、
'''
两者的输出结果都是：
exist
'''

基础流程控制

条件语句

• 关键字：if else 【elif】
• 条件语句行末要加冒号":"
• 条件内容部分不需要加括号

a,b,c = '1','0','0'
if a == b:
    print('a==b')
elif b==c:
    print('b==c')
else:
    print('other case')
'''
输出结果：
b==c
'''

循环语句

• pass 空语句，字如其名，代替留空的一个关键字，类似“占茅坑”

  numbers = range(5)#numbers: 0 1 2 3 4
  def getMyblog():
      pass # 留空占个位置，以后再写

while && else

• 没有括号，有冒号，没有分号，没有大括号

• 当条件while 第一次条件不成立的时候本次循环执行else后的代码

  • 当第二次条件不成立的时候直接退出循环

c = 5
while c >= 0:
    print('当前数字：',c,'满足循环条件')
    c=c-1
else:
    print('当前数字：',c,'不满足循环条件，这是最后一次循环，之后会退出循环')

# 输出结果
'''
当前数字： 5 满足循环条件
当前数字： 4 满足循环条件
当前数字： 3 满足循环条件
当前数字： 2 满足循环条件
当前数字： 1 满足循环条件
当前数字： 0 满足循环条件
当前数字： -1 不满足循环条件，这是最后一次循环，之后会退出循环
'''

range()

生成数列，并保存到数组中的一个函数，有两种用法如下

• range(length)

• range(firstindex,lastindex(,step=1))

  • 左开右闭如3-9只有3 4 5 6 7 8
  • step是步进，默认是1

for && in

• sequence n.序列
• 冒号！！！

# for value in sequence
# value: 每次枚举的每一个序列中的值
# sequence: 被枚举的序列
for data in range(115,1024,15):
    print(data)

函数 和 作用域

函数

• 定义关键字：def
• 有括号，有分号

• 没有大括号，结尾也不需要用什么标志结束，语句结尾也不需要分号

  def sumUp(a,b):
      return a+b
  def addFive(basis):
      return basis+5
  print(sumUp(1,2))#输出3
  print(addFive(4))#输出9

global局部变量全局化

global在局部使用（global varname），用于获取对应的全局变量（如果对应全局变量不存在则创建这个全局变量），在修改相当于直接修改全局变量

total = 1000
def addUp(n):
    total = 1000
    total += n
def addGlobalUp(n):
    global total
    total += n
addUp(200)
print(total)#输出1000
addGlobalUp(200)
print(total)#输出1200

def t(n):
    global t
    t = n
t(9)
print(t)#输出9

面向对象

对象基本使用

实例化的类：“生物”

class Student:
    def __init__(self,age,level,name):
        self.age = age
        self.level = level
        self.name = name

    def printName(self):
        print('his name is ',self.name)
he = Student('18',1,'hidden')
print(he)
he.printName()
'''
输出结果：
<__main__.Student object at 0x000001DF81501FD0>
his name is  hidden
'''

类的属性与方法

• 私有：类的私有属性或者方法命名时使用__开头，作用类似php中的private

• self：

  • 类的方法定义的时候必须在括号内包含self，代表实例化后的对象。
  • 类实例化后调用对象的方法不需要传入类，会自动传入self

class Boyfriend:
    name = "hidden" 
    __length,__height = "hidden","1.8+m" #私有属性
    def getName(self): #公有方法可以外部调用
        return name
    def __getLength(self): #私有方法不难外部调用
        return __length
    def get__Height(self): #公有方法可以外部调用，理解
        return __Height

类的两个常见析构方法

• __init__(self,....)在对象被创建的时候自动执行的方法

• __del__(self,....)在对象被销毁的时候自动执行的方法

  • 使用del关键字可以销毁对象
  • 对象会在所在进程结束的时候自动销毁

class Student:
    def __init__(self,age,level,name):
        self.age = age
        self.level = level
        self.name = name
        print(self.name + "被创建啦")
    def __del__(self):
        print(self.name + "被删除啦")
        
poilzero = Student(18, "middle", "poilzero")
del poilzero #加不加这一行输出结果是一样的，因为进程结束了会自动销毁对象

'''
输出结果：
poilzero被创建啦
poilzero被删除啦
'''

对象的继承与覆写

class Paper:
    def __init__(self,color):
        self.color = color
    def getColor(self):
        return self.color
class Model:
    def __init__(self,shape):
        self.shape = shape
    def getShape(self):
        return self.shape
class PaperModel(Paper,Model): # 双继承，单多继承同理
    def __init__(self,weight,color,shape): 
        # 继承后要执行继承对象的初始化函数
        Paper.__init__(self,color)
        Model.__init__(self,shape)
        self.weight = weight
    def printAll(self):
        print('weight:',self.weight)
        print('color:',self.color)
        print('shape:',self.shape)
    def getShape(self): #覆写方法，属性同理
        return 'hidden'
myboyfriend = PaperModel('average','white','boy')
myboyfriend.printAll()
print('getShape():',myboyfriend.getShape())

库的引入

import

完全引入模块后作为一个对象，然后把这个对象作为自己的成员
因此调用的时候需要 .模块的成员

# import 模块名
import sys
print(sys.path,end="")

from...import

• 与import区别：更精细的引入，可以引入具体哪几个成员
• 引入是把类的内容引入自己，然后最后再实例化自己
• 所以引入的成员实际上已经成为自己的成员，可以直接调用

# from 模块名 import 成员1,成员2,成员3
# from 模块名 import *
from sys import fun1,fun2
fun1()
fun2()
from sys import *
print(path,end="") # 同上的print(sys.path,end="")