Python基础笔记

aaa小葵

已于 2023-01-30 16:52:56 修改

阅读量164

点赞数

文章标签： python 开发语言 numpy

于 2023-01-28 20:46:30 首次发布

本文链接：https://blog.csdn.net/m0_74033027/article/details/128780998

版权

输出函数print

print('hello')
print(3+1)

a+表示追加，open打开文件,如果文件不存在，就创建，存在就在这个文件的后面继续追加

fp=open('D:/text.txt',"a+")
print('hello world',file=fp)
fp.close()
# 不换行输出
print('hello','readding',"lucy")

多个输出

a,b,c=10,20,30
print(a,b,c)

# 交换
a,b = b,a

元字符

不希望住转义字符起作用，在字符串前加上r或者R,最后一个字符不能是反斜杠

print(r'hello\nworld')

基础类型转换

str()将其他类型转为字符串类型
int()其他类型转为整数类型，文字和小数类字符串无法转换
float()其他类型转为浮点类型，文字无法转为浮点型
中文编码声明注释–>在文件的开头加上中文声明注释，用以指定源码文件的编码格式

a=int(input('输入：'))
b=int(input('输入：'))
print(a+b)

input()

作用：接受来自用户的输入
返回值为str类型
值的存储：使用=对输入的值进行存储

present = input('what are you want?')
a=input('输入a')
a=int(a)
b=input("输入b")
b=int(b)
print(a+b)

is 和 ==

#is比较的是id
#==比较的是value值

lis1=[1,2,3,4]
lis2=[1,2,3,4]
print(lis1 is lis2)#比较id--false
print(lis1==lis2)#比较value--true

and 和 or

a,b=1,2
print(a==1 and b==2)#true
print(a==1 or b==2)

in 和 not in

# not对运算数取反
s='hello'
# in在..里面
# not in在..中不存在
print('w' in s)#true
print('o' not in s)#false

左右移位

# 向左移位
print(3<<1)
# 向右移位
print(3>>1)

空列表/空元组/空字典/空集合

# 空列表
bool([])
bool(list())
# 空元组
bool(())
bool(tuple())
# 空字典
bool({})
bool(dict())
# 空集合
bool(set())

if语句

money = 1000
if money>100:
    money=money-100;
    print(money)

if money<=100:
    money-=900
    print(money)
elif money>=100:
    money+=200
    print(money)

pass

# pass可以在内容没想好的时候避免报错
if money=10:
    pass
elif money=20:
    pass
else:
    pass

for _ in range(5)在循环体中，如果不使用到自定义变量，可将自定义变量写为——

range()

range(stop)–[0,stop)之间整数序列，步长为1
range(start,stop)–创建一个[start,stop)之间的整数序列，步长为1
range(start,stop,step)–创建一个[start,stop)之间的整数序列，步长为step

r=range(1,9,3)
print(list(r))#[1, 4, 7]

例

# 行数
for i in range(1,4):
# 列数
    for j in range(1,5):
        print('*',end='\t')
    print()

# 打印直角三角形
# a=range(1,10)
a=1
for i in range(1,10):
    for j in range(1,i+1):
        print("*",end='\t')
    print()

列表

`append`

lst=[20,50,30]
lst.append(100)
print(lst)#[20, 50, 30, 100] id不变，内部值变化

lst2=['hello','world']
lst.append(lst2)
print(lst)#[20, 50, 30, 100, ['hello', 'world'] 将lst2当作一个整体放入

`extend`

lst3=['wo','shi','zhu']
lst.extend(lst3)
print(lst)#[20, 50, 30, 100, ['hello', 'world'], 'wo', 'shi', 'zhu'],将list3拆开放入

`insert`

在任意位置添加一个元素
lst.insert(1,70)
print(lst)#[20, 70, 50, 30]

切片`[1:]`

# 切片 在列表任意位置添加至少一个元素
lst4=['lolo','popo','uouo']
lst[1:]=lst4
print(lst)#[20, 'lolo', 'popo', 'uouo']

`remove`

lst=[10,90,30,50,20]
lst2=[10,60,60,80,20,20]
lst.remove(30)
print(lst)#[10, 90, 50, 20]
lst2.remove(60)
print(lst2)#[10, 60, 80, 20, 20]
#列表可以重复

`pop`

默认从最后一个开始删除，给定索引就删除索引位置，删除元素会重新构成新数组

lst=[10,90,30,50,20]
lst2=[10,60,60,80,20,20]
lst.pop()
lst2.pop(1)
newlist=lst.pop()
print(newlist)#[20]
print('1',lst)#[10, 90, 30, 50]
print('2',lst2)#[10, 60, 80, 20, 20]

切片

lst=[10,90,30,50,20]
lst2=[10,60,60,80,20,20]
newlst=lst[1:3]
print(lst)#[10, 90, 30, 50, 20]
print(newlst)#[90, 30]

lst[1:3]=[]
print(lst)#[10, 50, 20]

`clear`

lst.clear()
print(lst)#[]

`del lst` 直接删除列表

修改

lst=[10,20,30,40]
一次修改一个值
lst[2]=100
print(lst)#[10, 20, 100, 40]

修改多个值
lst[1:3]=[100,200,300,400]
print(lst)#[10, 100, 200, 300, 400, 40]

排序

调用sort()，列表中的所有元素默认按照从大到小的顺序进行排序，可以指定reverse=true，进行降序排序

lis=[20,40,10,90]
print(lis,id(lis))
lis.sort()
print(lis,id(lis))#[20, 40, 10, 90]
lis.sort(reverse=True)
print(lis)#[90, 40, 20, 10]

调用内置函数sorted()，可以指定reverse=true，进行降序排序，原列表不发生变化

newlis=sorted(lis)
print(lis)#[90, 40, 20, 10]
print(newlis)#[10, 20, 40, 90]

lst=[1,2,3,4,5,6]
# lst=[i*i for i in range(1,10)]
# print(lst)#[1, 4, 9, 16, 25, 36, 49, 64, 81]

lst=[i*2 for i in range(1,11)]
print(lst)#[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

字典

创建

sorces={'lolo':100,'pipi':200}
student=dict(name='plpl',age=18)

获取字典中的值

print(sorces.get('lolo'))
print(sorces['lolo'])
print(sorces.get('lolo',100))#100是在查找’lolo‘不存在时候的一个默认值

删

del sorces['dada']

改

sorces['jsck']=60

`.keys()`

将所有keys组成的视图转为列表

scores={'kiki':150,'lolo':160,'pipi':180}
news=scores.keys()
print(news)#dict_keys(['kiki', 'lolo', 'pipi'])
print(list(news))#将所有keys组成的视图转为列表['kiki', 'lolo', 'pipi']

`.values()`

将所有value组成的视图转为列表

values=scores.values()
print(values)
#dict_values([150, 160, 180])
items=scores.items()
print(items)
#dict_items([('kiki', 150), ('lolo', 160), ('pipi', 180)])

字典元素的遍历

for items in scores

for items in scores:
    print(items,scores[items],scores.get(items))
# kiki 150 150
# lolo 160 160
# pipi 180 180

d={item.upper():price for item,price in zip(items,prices)}

#zip将字典打包输出
items=['kiki','popo','vsvs']
prices=[20,50,60]
d={item.upper():price for item,price in zip(items,prices)}
print(d)#{'KIKI': 20, 'POPO': 50, 'VSVS': 60}

元组

内部id不可以改变，如果内部元素为可变元素就可以改变,比如里面是列表就可以在列表内部变化，这样列表的id不会发生变化

t=('lo','po')
t2=tuple(('lo','po','sl'))
print(t[0])

集合

集合中元素不许重复，并且会自动将重复值去掉

s={2,3,4,5,2,5}
print(s)#{2, 3, 4, 5}
s=set(range(6))
print(s)#{0, 1, 2, 3, 4, 5}
# 其他元素类型转为集合
s2=set([2,3,4])
s3=set((1,5,3,3))

判断

s={10,20,30,45}
print(10 in s)#True
print(20 not in s)#False

添加

s.add(52)
print(s)#{10, 45, 20, 52, 30}
s.update({26,99,82})
print(s)#{82, 26, 20, 99, 10, 45, 30}
s.update([100,68])
print(s)#{100, 68, 10, 45, 20, 30}
s.update((1,69,33))
print(s)#{1, 33, 69, 10, 45, 20, 30}

删除

s.remove(10)#{20, 45, 30}
s.remove(9333)#KeyError: 9333
s.discard(500)#错误不会有异常
s.discard(20)#{10, 45, 30}

s.pop()随机删除一个，不能指定参数
s.clear() 清空集合元素

集合是否相等

1.元素相同
2.一个集合是否为另一个集合的子集

交/并/差集

# 交集
s1={12,20,30,40}
s2={20,30,50}
print(s1.intersection(s2))#{20, 30}
print(s1 & s2)#{20, 30}
# 并集
print(s1.union(s2))#{50, 20, 40, 12, 30}
print(s1| s2)#{50, 20, 40, 12, 30}
# 差集
print(s1.difference(s2))#{40, 12}
print(s1-s2)#{40, 12}
# 对称差集
print(s1.symmetric_difference(s2))
print(s1^s2)#{40, 12, 50}

字符串

字符串的驻留机制

# 字符串的驻留机制
a='Python'
b='''Python'''
c="Python"
print(a,id(a))
print(b,id(b))
print(c,id(c))

字符串的查询

# 字符串的查询
a='hello.heloo'
print(a.index('h'))#0 从前往后找，0查找字符不存在报错
print(a.rindex('h'))#6 从后往前找，0查找字符不存在报错
print(a.find('o'))#4  从前往后找，查找字符不存在返回-1
print(a.rfind('o'))#10 从后往前，查找字符不存在返回-1

字符串大小写转换

s='hello POPO'
w=s.upper()#全部转为大写
print(s,id(s))#hello POPO 2220374066928
print(w,id(w))#HELLO POPO 2220374067568
w=s.lower()#全部转为小写
print(s,id(s))#hello POPO 2220374066928
print(w,id(w))#hello popo 2220374067568
w=s.swapcase()#字符串内大写转小写，小写转大写
print(s,id(s))#hello POPO 1542036031216
print(w,id(w))#HELLO popo 1542036032240
w=s.capitalize()#第一个字符转大写，其余转小写
print(s,id(s))#hello POPO 1542036031216
print(w,id(w))#Hello popo 1542036032176
w=s.title()#每个单词的第一个字符转大写，每个单词的剩余字符转小写
print(s,id(s))#hello POPO 1542036031216
print(w,id(w))#Hello Popo 1542036032240

字符串内容对齐操作的方法

在这里插入图片描述

center(指定宽度，指定填充符) 居中对齐 设置宽度小于原字符串宽度返回原先字符串
ljust(指定宽度，指定填充符) 左对齐
right(指定宽度，指定填充符) 右对齐
# zfill() 右对齐，左边用0填充，该方法只接受一个参数，用于指定字符串宽度
s.center(20,"*")
s.ljust(30,"+")
s.rjust(10,"*")
s.zfill(60)

字符串其他操作方法

在这里插入图片描述

s='hello+world+nice'
lst=s.split(sep='+')
print(lst)#['hello', 'world', 'nice']
lst2=s.split(sep='+',maxsplit=1)
print(lst2)#['hello', 'world+nice']

e='hello,kugo'
print(e.replace('kugo','qq'))#hello,qq
e2='hello,kugo,sjsj,kugo,lolo,jwjw,kugo'
print(e2.replace('kugo','qq',2))#hello,qq,sjsj,kogo,lolo,jwjw,qq

lst=['python','java','c++']
t=('python','java','c++')
print(''.join(lst))#pythonjavac++
print('+'.join(t))#python+java+c++

切片

q='hello,pyton'
print(q[1:5:2])#el 从1开始，切到5结束，包头不包尾，步长为2

占位符

name="大耳朵图图"
age=10
print("我是%s,我今年%d碎了" % (name,age))#我是大耳朵图图,我今年10碎了
print('我叫{0}，今年{1}岁'.format(name,age))#我叫大耳朵图图，今年10岁
print(f'我叫{name},今年{age}岁')#我叫大耳朵图图,今年10岁

表示宽度和精度

# 表示宽度和精度
print('%10d' % 99)#10表示宽度
print('%.3f' % 3.1415926)# .3表示小数点后三位
print('%10.3f' % 13.1415926)

print('{0:.3}'.format(3.1415))#表示三位数3.14
print('{0:.3f}'.format(3.1415))#表示三位小数3.142
print('{0:10.3f}'.format(3.1415))#     3.142

编码/解码

编码格式和解码要相同

s='天涯共此时'
print(s.encode(encoding='GBK')) #在GBK这种编码方式中，一个中文站两个字节 b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
print(s.encode(encoding='UTF-8'))#在UTF-8这种编码方式中，一个中文站三个字节 b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
# 解码 编码格式和解码要相同
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))

calc

def calc(a,b):
    c=a+b
    return  c
# result=calc(10,20)
result=calc(b=10,a=20) #左侧的变量名称称为 关键字参数 可以不按照顺序
print(result)

*args/**args

def fun(*args): #函数定义时候用*定义个数可变的位置参数 只能有一个
    print(args)
    print(args[0])

fun(10)#(10,)
fun(10,20,30)#(10, 20, 30)

def fun2(**args):
    print(args)
   
fun2(a=10)
fun2(a=10,b=20)

def fun3(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)

lst=[11,22,33]
fun3(*lst)
dict={'a':100,'b':200,'c':400}
fun3(**dict)

#从*之后的参数必须采用关键字形参传递

def fun4(a,b,*,c,d):#从*之后的参数必须采用关键字形参传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

fun4(10,b=20,c=30,d=40)

函数定义时候的位置问题

def fun4(a,b,*,c,d)
def fun5(*args,**args2)
def fun6(a,b=10,*args,**args2)

def fun5():
    global age#在函数内部定义的变量 添加global声明 这个变量实际上就变成了全局变量
    age=20
    print(age)

阶乘

# 阶乘
def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)
print(fac(5))

Python异常处理机制

1.try...except...

try:
    a=int(input('请输入第一个整数：'))
    b=int(input('请输入第二个整数：'))
    result=a/b
    print('结果为：',result)
except ZeroDivisionError:
    print('除数不能为0')
except ValueError:
    print('只能输入字符串')
print('程序结束')
请输入第一个整数：8
请输入第二个整数：0
除数不能为0
程序结束

请输入第一个整数：5
请输入第二个整数：ll
只能输入字符串
程序结束

2.try-except-else 出错走except，不出错走else，finally最后都会运行

try:
    a=int(input('请输入第一个整数：'))
    b=int(input('请输入第二个整数：'))
    result=a/b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
finally:
    print('thanks for you')

3.打印异常信息import traceback

try:
    print(1/0)
except:
    traceback.print_exc()

类

在类之外称为函数，在类里定义的称为方法实例方法
直接写在类里面的变量称为类属性
静态方法@staticmethod
类方法@classmethod

class Student:#每个单词的首字母大写
    native_pace='黄山'#直接写在类里面的变量称为 类属性
    def __init__(self,name,age):#self/name称为实例属性，进行了一个赋值的操作，将局部变量的name赋值给实例属性
        self.name=name
        self.age=age
    # 在类之外称为函数，在类里定义的称为方法 实例方法
    def eat(self):
        print('学生没饭吃')
    # 静态方法
    @staticmethod
    def method():#静态方法没有形参
        print("wowowowowowowowo")
    # 类方法（形参是类名）
    @classmethod
    def cm(cls):
        print('popopopopo')

创建student类的对象

# 创建student类的对象
stul=Student('aliy',18)
print(id(stul))#2256142832016
print(type(stul))#<class '__main__.Student'>
print(stul)#<__main__.Student object at 0x0000020D4C979190>

1.对象名.方法名()
2.`类名.方法名(类的对象)

# 对象名.方法名()
stul.eat()#学生没饭吃
# 类名.方法名(类的对象)
Student.eat(stul)#学生没饭吃
Student.cm()#popopopopo
Student.method()#wowowowowowowowo
stul.cm()#popopopopo
stul.method()#wowowowowowowowo

继承

class Person(object):#object可写可不写，说明person继承了object类
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

class Student(Person):#让Student继承Person
    def __init__(self,name,age,grade):
        super().__init__(name,age)
        self.grade=grade

class Teacher(Person):
    def __init__(self,name,age,payment):
        super().__init__(name,age)
        self.payment=payment
        # 方法重写
    def info(self):
        super().info()#调用父类的方法
        print('一个月工资：',self.payment)#相当于在原先基础上添加了一项，当子含有该方法，就先调用子类方法

stu=Student('kiki',15,98)
teacher=Teacher('popo',36,1230)

stu.info()
teacher.info()
print(stu.name)
print(stu.grade)

特殊属性

class A():
    pass
class B():
    pass
class C(A,B):#c继承A，B
    def __init__(self,name,age):
        self.name=name
        self.age=age
x=C('cc',18)
# 实例对象的属性字典
print(x.__dict__)#{'name': 'cc', 'age': 18}
# 类对象属性字典
print(C.__dict__)#{'__module__': '__main__', '__init__': <function C.__init__ at 0x000002B718FAA5C0>, '__doc__': None}
# class属性，输出对象所属的类
print(x.__class__)#<class '__main__.C'>
# bases属性，输出父类类型的元素
print(C.__bases__)#(<class '__main__.A'>, <class '__main__.B'>)
# base属性，输出父类类型的第一个元素
print(C.__base__)#<class '__main__.A'>
# 类的层次结构
print(C.__mro__)#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
# 查看子类列表
print(A.__subclasses__())#[<class '__main__.C'>]

特殊方法

a=10
b=30
d=a.__add__(b)
print(d)
# 两个字符串相加
class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        return self.name+other.name
stu1=Student("popo")
stu2=Student("kiki")
s=stu1+stu2
print(s)#popokiki
m=stu1.__add__(stu2)
print(m)#popokiki
list=[11,22,33,44]
print(list.__len__())#4
print(len(list))

`new()和init()`

# new先创建对象，init再对创建的对象初始化
class Person(object):
    #1.这里的cls传入的就是Person，‘宝宝’和20被传入后面当变量
    def __new__(cls, *args, **kwargs):
        obj=super().__new__(cls)# 2.创建一个变量，它使用的cls依旧是person
        return obj#3.返回这个变量给下面的__init__()方法，作为init的self对象
    def __init__(self,name,age):
        self.name=name
        self.age=age
#4.最后走完全部流程，又将最后结果传递给p作为结果
p=Person('宝宝',20)

浅拷贝/深拷贝

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,name,age):
        self.name=name
        self.age=age
cpu1=CPU()
cpu2=cpu1
disk=Disk()
computer=Computer(cpu1,disk)
# 浅拷贝 两个拷贝对象地址不同，但是两者的子对象地址相同
import copy
computer2=copy.copy(computer)
# computer2和computer的子对象cpu1和disk都是相同的id，但是computer和computer2的id不同

# 深拷贝
computer3=copy.deepcopy(computer)
#computer2和computer的子对象cpu1和disk都是也相同的id

模块

1.import 模块名称 [as别名] 导入模块中的一切
2.form 模块名称 import 函数/变量/类 导入模块中指定的部分
3.导入自定义模块
方式一：目录下单击右键点击mark directory as 再点击sources root
方式二：from calc import add

# 1.import 模块名称 [as别名] 导入模块中的一切
import math
print(id(math))#2216730235648
print(type(math))#<class 'module'>
print(math)#<module 'math' (built-in)>
print(math.pi)#3.141592653589793
# 查看内部更多属性
print(dir(math))
# 2.form 模块名称 import 函数/变量/类 导入模块中指定的部分
from math import pi
from math import pow #必须先声明该函数才能使用
print(pow(2,6))
print(math.pow(2,6))
# 3.导入自定义模块
# 方式一：目录下单击右键 点击mark directory as 再点击sources root
import calc
print(calc.add(10,20))#30
print(calc.div(30,6))#5.0
# 方式二：
from calc import add
print(add(10,20))

包

导入包

# 导入包
import bag.module_A as ma # ma是别名
print(ma.a)
# 1.用import导入只能使用包名或者模块名
import bag
import calc
# 2.用from导入包/模块/函数/变量
from bag import module_A
from bag.module_A import a

常见模块

import sys
print(sys.getsizeof(24))
import urllib.request
print(urllib.request.urlopen('http://www.baidu.com').read())# 读取网页信息

eg.

import schedule
import time
def job():
    print('haha')
schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1) #每隔三秒休息一秒

file=open('a.txt','rb')#读取
# newfile=open("copytxt",'wb')#创建新文件
print(file.read(2))
# newfile.write(file.read())#将读取的内容写入新文件
# newfile.close()#关闭文件
# file.close()

os模块与操作系统相关的模块

os.system('notepad.exe') # 打开记事本
os.system('calc.exe') # 打开计算器
os.startfile("C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\qq.exe")#打开qq
print(os.getcwd()) #当前操作路径 D:\pythonProject\venv
print(os.listdir('../test1.py'))
os.mkdir('newdir2') 创建目录
os.makedirs('A/B/C') #创建多级目录
os.rmdir('newdir')#删除目录
os.removedirs('A/B/C')# 删除多级目录

获取指定目录下的所有py文件
path=os.getcwd()
list=os.listdir(path)
for filename in list:
    if filename.endswith('.py'):
        print(filename)

不但将文件列出，还能将文件下的子文件也列出
path=os.getcwd()
lst=os.wait(path)
for dirpath,dirname,filename in lst
    print(dirname)
    print(dirpath)
    print(filename)

aaa小葵

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python基础笔记

内部id不可以改变，如果内部元素为可变元素就可以改变,比如里面是列表就可以在列表内部变化，这样列表的id不会发生变化。a+表示追加，open打开文件,如果文件不存在，就创建，存在就在这个文件的后面继续追加。中文编码声明注释–>在文件的开头加上中文声明注释，用以指定源码文件的编码格式。默认从最后一个开始删除，给定索引就删除索引位置，删除元素会重新构成新数组。，可以指定reverse=true，进行降序排序，原列表不发生变化。，列表中的所有元素默认按照从大到小的顺序进行排序，可以指定。
复制链接

扫一扫