1.输出代码到文件上去
python三种格式化输出:
(48条消息) Python格式化输出的三种方式_Z朱先生。的博客-CSDN博客
fp=open('D:/text1.txt','a+') #a+的意思是如果不存在就创建，如果存在的话就后面继续追加
print("hello world!",file=fp)
fp.close()
2.转移字符
\n 换行
\t 制表符，一组四个字符
\r 回车
\b 退一个格
不希望转义字符起作用，那就在前面加一个r,例如print(r"heeloo\nworld") 它最终输出的是 heeloo\nworld,当然最后一个字符不是是斜杠
3. Unicode的转换
print(chr(0b100111001011000))
print(ord('以'))4.关键字
import keyword
print(keyword.kwlist)5.存储类型
不管什么东西，加上单引号或者双引号就是str字符串类型
布尔类型可以转换为整数，True为1，False为0
三引号单双可以换行，都是为str字符串类型。
在Python中，False,0,’’,[],{},()都可以视为假
6.注释
7.输入函数
输入的自动为str类型，要进行加减乘除的话得提前进行类型强制转换
8.运算符
//为整除运输符号，**为多少次方
9.赋值
解包赋值a,b=b,a
比较运算符若要比较两者的标识也就是地址用is
a is b #标识a的标识与b的一致，当然这是个布尔类型
a is not b
注意一下map函数的用法
10.其他函数
11.列表
输出不换行用end函数
format函数，split函数，len函数,strip函数CSDN上面自己搜用法
list2=list([1,2,3,4])
print(list2)索引正序是0，逆序是-1，分别对应正数第一和倒数第一
12.列表的增删改查
list1=['hello',23,'gh',56]
list2=['23',56,'aeae']
list1.append(200)
print(list1)
list1.extend(list2)
print(list1)
list1.insert(1,'ajehakejh')
print(list1)
pop()默认删除最后一个元素 ,reverse函数的用法，eval函数的用法
list1=['hello',23,'gh',56,33,44,55,66]
list1.remove(23)
print(list1)
list1.pop()
print(list1)
new_list=list1[1:3]
print(new_list)
list1.clear()
print(list1)
del list1
print(list1)list1=[1,2,3,4,5,6]
list1[0]='heel'
print(list1)
list1[1:3]=['asae','aeaeeqw','fsggdsa','kilt']
print(list1)13.列表的排序
list1=[3,45,21,1,0,69,82,35]
list1.sort(reverse=True)
print(list1)13.列表生成式
list1=[item for item in range(1,10)]
print(list1)14.字典
冒号之前为键，冒号之后为值，所以也叫键值对
score={'张三':99,'李斯':123,'尼玛':56}
print('张三' not in score)
del score['尼玛']
print(score)
score['阿木']=234 #既可以新增，也可以对已有的键进行修改
print(score)
score={'张三':99,'李斯':123,'尼玛':56}
print(score.keys())
print(type(score.keys()))
print(score.values())
print(type(score.values()))
print(list(score.values()))
print(list(score.keys()))
print(score.items())
print(list(score.items())) #转换之后的列表元素由元组组成
score={'张三':99,'李斯':123,'尼玛':56}
for item in score:
print(item,score[item],score.get(item))
#实际上是对键进行遍历，而不是对值进行遍历 
牛客网上面的题目：
s1={'A':4.0,'B':3.0,'C':2.0,'D':1.0,'F':0}
print(s1['A'])
s2=[1,2,3,4,5,6,]
print(sum(s2))
s3=[]
while True:
g=input()
if g=='False':
break
else:
sco=int(input())
s2.append(s1[g]*sco) #找字典中的元素利用键去找,s1为一字典找字典中的值可以用s1[key]来找
s3.append(sco)
print("%.2f"%(sum(s2)/sum(s3))) #sum是求一个列表的和函数,前提是其中的元素必须是整形score={'name':'张三','name':'李斯'}
print(score)
score={'name':'张三','nigername':'李斯'}
print(score)
item=['aea','sadag','asfgg']
score=[12,34,56]
list1=zip(item,score)
print(list(list1))
print({item:score for item,score in zip(item,score)})列表转字符串：CSDN自己搜
15.元组
元组也可以切片
tuple可以把列表转元组，切片可以遍历所有的元素即使他没有
元组的合并可以用+号连接
a=(1,2,3)
b=(3,4,5)
print(a+b)
type='ajkelk',235,67.2
sch=(12,)
score=tuple(('aeae',234,56.2))
print(score)
print(type)
print(sch) 
16.集合
s=set(range(6))
print(set([1,2,3,4]))
print(set((1,2,3,4,4,5,5,6)))
print(set('Python'))
print(set({23,3,4,56,78}))
print(set())
#集合本身是无序，且无重复元素的
list1={1,2,3,4,56,7,8}
print(1 in list1)
print('python' not in list1)
list1.add(23)
print(list1)
list1.update({200,300,400})
print(list1)
list1.update((0,-1,-2,-3))
print(list1)
list1.remove(0)
print(list1)
list1.pop() #必须是无参数的
print(list1)
s1={1,2,3,4}
s2={2,3,4,5}
print(s1==s2)
print(s1!=s2)
list1={1,2,3,4,5,6,7,8}
list2={2,3,4,5,6}
list3={2,3,4,5,0}
print(list2.issubset(list1))
print(list3.issubset(list1))
print(list1.issuperset(list2))
print(list3.issuperset(list1))
print(list2.isdisjoint(list1))
print(list3.issuperset(list1))
#没有交集为True，有交集为False
s1={1,2,3,4,5}
s2={3,4,5,6,7}
print(s1.intersection(s2))
print(s1 & s2)
print(s1.union(s2))
print(s1|s2)
print(s1.difference(s2))
print(s2.difference(s1))
print(s1-s2)
print(s1.symmetric_difference(s2))
print(s1^s2) 
17.字符串
字符串同样可以切片
a='python'
b="python"
c='''python'''
print(id(a))
print(id(b))
print(id(c)) 
a='python'
print(a.index('t'))
print(a.find('t'))
print(a.rindex('t'))
print(a.rfind('t'))
print(a.find('k'))
print(a.rfind('k')) 
转换之后，会产生一个新的对象，即地址发生变化
s1='hello,python'
print(s1.center(20,'*'))
print(s1.ljust(20,'*'))
print(s1.rjust(20))
print(s1.zfill(20))
print('-1234'.zfill(10))字符串去空格搜CSDN：
s1='hello python gih'
print(s1.split(sep='o'))
print(s1.split(sep='o',maxsplit=1))
print(s1.rsplit(maxsplit=1)) 
s1='hello,python'
print(s1.isidentifier()) #合法字符是字母，数字，下划线
print('heelo'.isidentifier())
print('1.','\t'.isspace())
print('2.','abc'.isalpha())
print('3.','123'.isdecimal())
print('4.','123456'.isnumeric())
print('5.','23a'.isalnum()) 
s='人生苦短，我用Python'
s='人生苦短，我用Python Python Python'
print(s.replace('Python','Java',2))
s1=('a','b','c')
s2=['hello','java']
print('*'.join(s2))
print(''.join(s2))
print(''.join(s1)) 
print('apple'>'app')
print(ord('a'))
print(chr(97))
print(ord('汤'))
#is 比较的是内存 == 比较的是Value 
s1='hello,python'
print(s1[:5])
print(s1[6:]) #产生了新的地址
#[:5]是默认到5前面一个元素,而[6:]是包含最后一个元素
print(s1[:5]+'!'+s1[6:])字符串的格式化：
s='海上生明月'
print(s.encode(encoding='GBK')) #一个中文占两个字节
print(s.encode(encoding='UTF-8')) #一个中文占三个字节
#解码
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))end不换行输出
18.函数
def sum(a,b): #形参的位置是在函数的定义处
c=a+b
d=a-b
return d
result=sum(5,6) #5,6作为实际参数的值，称为实参
print(sum(b=20,a=30)) #关键字参数赋值 
如果是不可变对象，在函数体的修改不会影响实参的值
def sum(**args):
print(args)
# def sum(**args):
# print(args)
# print(sum(1,2,3,4,5))
位置参数和关键字参数只能定义一个
sum(a=10,b=20,c=30) 
def sum(a,b,c):
print(a)
print(b)
print(c)
print(*[11,22,33]) #在函数调用时，将列表中每个元素都转换为位置实参调入def fun4(a,b,*,c,d): #从*之后的参数,在函数调用时,只能采用关键字参数传递
print('a',a)
print('b',b)
print('c',c)
print('d',d)
fun4(1,2,3,4)
fun4(a=0,b=1,c=2,d=3)
fun4(11,22,c=33,d=44) 
def sum():
global name #global声明了之后可以将函数体内的函数生命域扩充到函数体外面
name='阿木'
sum() #但是你要调用的话,前提是先调用函数内的文件
print(name)
19.BUG
except BaseException as e:
print('出错了')
//Base是包含一切错误的最大的 
Python常见的异常：
list=[1,2,3,4]
print(list[4])
dic={'name':'张三','age':'12'}
print(dic['gender'])
print(num)
int a=20
int a='hello'
以上会打印出错误
20.程序调试
21.类与对象
class Student_Key:
native_space='东北三省' #类属性
def __init__(self,name,age): #初始化方法,这是一个赋值的操作
self.key=name #self.key称为实例属性，将一个局部变量name的值赋给了实体属性
self.age=age
def eat(self): #实例方法,在类之外定义的为函数,在类之内定义的称为方法
print('吃答辩')
@staticmethod
def method():
print('我使用了静态方法')
@classmethod
def method(cls):
print('我使用了类方法')
#python中一切皆对象
#创建Student类的对象
soul=Student_Key('张三',23)
print(soul.key)
print(id(Student_Key))
print(type(Student_Key))
print(Student_Key) #value值
print('hello,world!')
class Student_Key:
native_space='东北三省' #类属性
def __init__(self,name,age): #初始化方法,这是一个赋值的操作,name,age是传进来的实参
self.key=name #self.key称为实例属性，将一个局部变量name的值赋给了实体属性,key,age是对象的属性
self.age=age
def eat(self): #实例方法,在类之外定义的为函数,在类之内定义的称为方法
print('你这是违法行为,走,跟我去自首')
@staticmethod #静态方法
def method():
print('我使用了静态方法')
@classmethod #类方法
def method(cls):
print('我使用了类方法')
#python中一切皆对象
#创建Student类的对象
soul=Student_Key('张三',23)
print(soul.key)
print(soul.age)
print(id(Student_Key))
print('_______________')#两种调用类方法的实例
soul.eat()
Student_Key.eat(soul)
print(type(Student_Key))
print(id(Student_Key))
print(Student_Key) #value值
print('hello,world!')
class Student_Key:
native_space='东北三省' #类属性
def __init__(self,name,age): #初始化方法,这是一个赋值的操作,name,age是传进来的实参
self.key=name #self.key称为实例属性，将一个局部变量name的值赋给了实体属性,key,age是对象的属性
self.age=age
def eat(self): #实例方法,在类之外定义的为函数,在类之内定义的称为方法
print('你这是违法行为,走,跟我去自首')
@staticmethod #静态方法
def method1():
print('我使用了静态方法')
@classmethod #类方法
def method2(cls):
print('我使用了类方法')
#python中一切皆对象
#创建Student类的对象
soul=Student_Key('张三',23)
print(soul.key)
print(soul.age)
print(id(Student_Key))
print('_______________')#两种调用类方法的实例
soul.eat()
Student_Key.eat(soul)
#调用类属性的两种方法
print(soul.native_space)
print(Student_Key.native_space)
#在外面修改类属性
Student_Key.native_space='天津'
print(soul.native_space)
print(Student_Key.native_space)
#类方法的调用直接通过类去调用,不需要去创建对象，静态方法同理,如果静态方法与类方法同名,那么会优先调用类方法
Student_Key.method2()
Student_Key.method1()
print(type(Student_Key))
print(id(Student_Key))
print(Student_Key) #value值
print('hello,world!')
class Student:
native_space='吉林'
def __init__(self,name,age,xingwei):
self.name=name
self.age=age
self.anothername=xingwei
def eat(self):
print(self.name+'在吃答辩')
@staticmethod
def method():
print("我使用了静态方法")
@classmethod
def method1(cls):
print('我使用的是类方法')
stu1=Student('吴京',23,'答辩')
stu2=Student('孙国帅',25,'大肠')
print(stu2.anothername)
print(stu1.name)
stu2.gender='男'
print(stu2.gender)动态绑定属性
动态绑定方法
def show():
print('来吧,展示')
class Student:
native_space='吉林'
def __init__(self,name,age,xingwei):
self.name=name
self.age=age
self.anothername=xingwei
def eat(self):
print(self.name+'在吃答辩')
@staticmethod
def method():
print("我使用了静态方法")
@classmethod
def method1(cls):
print('我使用的是类方法')
stu1=Student('吴京',23,'答辩')
stu2=Student('孙国帅',25,'大肠')
print(stu2.anothername)
print(stu1.name)
stu2.gender='男'
stu2.show=show
stu2.show()
print(stu2.gender)
绑定只能绑定在具体的对象上
21.对象的封装继承和多态
class Car:
def __init__(self,brand,name,age):
self.brand=brand
self.name=name
self.__age=age #年龄不希望被外部使用,加两个下划线
def start(self): #可以通过。类方法来调用
print('启动了',self.__age)
car=Car('宝马','答辩',23)
car.start()
print(dir(car))
print(car._Car__age) #在类的外部通过_Car__age来调用实例属性 
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print('姓名是{0},年龄是{1}'.format(self.name,self.age))
class People(Person):
def __init__(self,name,age,number):
super().__init__(name,age) #调用父类的方法
self.number=number
class P1(Person):
def __init__(self,name,age,type):
super().__init__(name,age)
self.type=type
stu=People('吴京',35,'2003')
stu2=Person('孙国帅',36)
stu2.info()
stu.info() #从父类继承过来的
stu3=P1('hell',23,'崽种')
print(stu3.type)
print(stu.number)
可以进行多继承
方法重写(丢失)
22.特殊方法和属性
a=100
b=20
c=a+b
d=a.__add__(b) #底层调用了add方法
print(c)
print(d)
class Student():
def __init__(self,name):
self.name=name
def __add__(self, other):
return self.name+other.name
def __len__(self):
return len(self.name)
stu1=Student('Jack123')
stu2=Student('Chen')
print(stu1+stu2) #实现了两个对象的加法运算,在Student类中，编写了特殊的方法
list1=[1,2,3,4]
print(len(list1))
print(list1.__len__())
print(len(stu1))
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
#变量的赋值
cpu1=CPU
cpu2=cpu1
print(cpu1)
print(cpu2)
disk=Disk()
computer=Computer(cpu1,disk) #创建一个计算机类的对象,传入两个对象
#浅拷贝
import copy
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
23.百宝箱
模块：
自定义模块
import math #关于数学运算的一个模块
print(id(math))
print(type(math))
print(math)
print(math.pi)
print('------------')
print(dir(math))
print(math.pow(2,8),type(math.pow(2,5)))
print(math.ceil(9.001))
print(math.floor(9.999))
from math import pi
print(pi) 
def add(a,b,c):
return a*b*c
def div(a,b):
return a/b
if __name__ == '__main__': #只有当运行demo1时才会执行
print('我是在demo1中的饿哦')
import demo1
print(demo1.add(2,3,4)) Python中的包
import package1.module_A as b
print(b.a )
#使用import方式导入时,只能跟包名或模块名
from package1.module_A import a #使用from可以导入包,模块,函数,变量
import sys
import time
import calendar
import urllib.request
print(urllib.request.urlopen('http://www.baidu.com').read())24.第三方模块的安装和使用
打开cmd窗口,输入pip install 包名进行安装
Python软件包中的可以继续安装，在cmd里面安装的Pycharm用不了，此处存疑，后续解决
25.大宝藏
#encoding=gbk
修改编码格式文件的读写能力
file=open('a.txt','r')
print(file.readlines())
file.close() 
class Student(): #该类对象遵守了上下文管理器协议
def __enter__(self):
print('我使用了管理类方法')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('使用了exit方法')
def show(self):
print('show方法被使用了')
with Student() as file: #相当于一个file=Student()
file.show() 
扫一扫
2511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
