列表为复习快速清单，每一个序号代表一天复习的内容。
目录
一、Python 基础复习
1、基础
下载软件，sublime，pycharm。初学时在sublime上夯实基础，脚踏实地写代码；
- 注释，
- 变量，
- 数据类型及相互转换，
- 运算符，
- input，print
2、分支和循环
- if else, elif,
- while, for,
- break, continue。
练习：猜数字，99乘法表，水仙花数
##实现一个体质计算器
gender = str(input("Please input your gender:"))
waist = float(input("Please input your waist:"))
weight = float(input("Please input your weight:"))
if gender=="Female" or gender=="female":
p1 = waist*0.74
p2 = weight*0.082+34.89
carlo = p1-p2
percent_carlo = (carlo/weight)*100
elif gender=="Male" or gender=="male":
p1 = waist*0.74
p2 = weight*0.082+44.74
carlo = p1-p2
percent_carlo = (carlo/weight)*100
else:
print("Please input the right info again!")
print("your percent_carlo is: ",percent_carlo)
##for loop to realize the 9*9 sheet
row = 1
col = 1
for row in range(1,10):
for col in range(1,row+1):
print("%s×%s=%s"%(col,row,col*row)+" ",end='')
row+=1
col+1
print("")
##找出1000以内的水仙花数
for s in range(1,1001):
a = s//100
b = (s-a*100)//10
c = s-a*100-b*10
if a**3+b**3+c**3 == s:
print(s)3、字符串
- 字符串拼接（加号，格式化拼接），
- 字符串格式化（%s, {} format() )，
- 字符串的下标操作( var[-1] )，
- 字符串的切片操作：var[start, end, step] , step为正数从左到右，负数相反，元组操作，
- 字符串的常用方法：var.find(), var.index(), len(var), var.count(), var.replace(), var.split(), var.startswith(), var.endwith(), var.lower(), var.upper(), var.strip(), var.lstrip(), var.rstrip(), var.partition(), var.isalnum(), var.isalpha(), var.isdigit(), var.issapce(), format()
- 常见转义字符：\, \n, ' \' ', \t,
- 原生字符串：(raw), print(r'making progresss \neveryday')
- 字符串的编码和解码：unicode是一个万能字符集，但不能传输和加密，所以需要准换成byte类型，编码方式有utf-8、gbk、ASCII。例如使用哈希加密之前必须编码，否则报错。但有时也要看使用的函数规定是否需要编码，有可能该函数底层逻辑已经写入了编码。
- var.encode("utf-8")
- b'hello world', var.decode("utf-8")
练习
# t ="""I am xiaoxiao. I go to school for several years. I want to be a doctor in the future in 2999"""
'''
1. 把上面字符串的所有空格删除，并保存在另外一个新的字符串中
2. 判断以上单词的个数
3. 把包含了t的单词找出来，不区分大小写
4. 把所有数字都找出来
'''
t ="""I am xiaoxiao. I go to school for several years. I want to be a doctor in the future in 2999"""
delete_sapce = t.replace(" ","")
print(delete_sapce)
count_word = len(t)-t.count(" ")
print(count_word)
t1 = t.split(" ")
for word in t1:
if word.find("t")>0 or word.find("T")>0:
print(word)
else:continue
for word in t1:
if word.isdigit()>0 or word.isdigit()>0:
print(word)
else:continue
'''
把一下变量用format函数写一个连接数据库的语句
#用户名
username = 'a'
port = 3333
'''
username = 'a'
port = 3333
a = 'username: {aa}, port: {bb}'.format(aa=username,bb=port)
print(a)4、列表、元组、字典
- 定义列表 ：var = ["a","b","c",...]
- 列表下标取值： var[0], var[-1]
- 遍历列表：使用for循环或while，但通常选择用for
-
for word in words: print(word) ################ index = 0 while index<len(words): print(words[index]) index +=1
-
- 列表的基本使用：
- 储存任何数据类型
- 列表相加，加在后面
- 列表的切片操作，和字符串的操作一样：var[start:end:step]
- append: var.append()
- count: var.count()
- extend: var.extend()，会改变原来变量的值
- index: var.index()，找出某个值第一次出现的位置
- insert: var.insert(index,object)，改变原变量的值
- pop: var.pop()，会改变原变量的值，并且返回移除的值
- remove: var.remove(object)，会改变原变量的值，不会返回移除的值，只会移除遇到的第一个值
- reverse: var.reverse()，会改变原变量的值
- sort: var.sort()，会改变原变量的值
- sorted: sorted(var)，不会改变原变量的值
- del: del var[ ]，根据下标删除值，会改变原变量的值
- in: for "A" in LIST
- list: list(var)
- 元组的基本使用：只能读取、遍历是不可变的类型
- 定义元组
- 定义1个元素的元组: var = 1, var = (1,)
- tuple: var = tuple(iterable var)，可以遍历的元素，比如list
- 圆括号：var = (1,2,3)
- 使用逗号：var = 1,3,5
- 元组常用操作：
- 下标操作：var[1]
- 切片操作: 和列表一样
- 解组操作：var1,var2,var3 = var，或者 var1,var2,_ = var
- count: var.count()
- index: var.index()
- 为什么会有元组？
- 在字典中当作key来使用，因为是不可变的
- 返回多个值时
- 在一些不希望用户改变值的场景下
- 字典的基本使用：
- 为什么用字典？想要储存一些信息，比如一个人的简历，借助关键词和对应的值形式来储存信息。无序的。若要储存多个人的简历，就用列表将这些字典储存起来。
- 创建字典：
- var = {"var1":"a", "var2":12}
- dict: dict(var1 = "a", var2 = 12)
- 基本操作：
- len: len(var)，关键词的个数
- 获取关键词：var["var1"]
- 修改关键词对应的信息：var["var1"] = "aa"
- 添加关键词：如果输入不存在的关键词赋值操作，便为增加
- 删除关键词：del var["var1"]
- 判断关键词是否在字典中：使用遍历
- 字典中的key为任何不可变的类型，如浮点类型，整形，元组
- 字典常用方法：
- clear：var.clear()，这个和赋值空置有些不一样，一个全部清除，一个只清除赋空置的那个
- get：不会抛出异常，和下标操作不一样，var.get()
- pop：var.pop()，会返回移除的值
- popitem: 随机移除字典中的一个值
- update：合并两个字典，var.update()
- setdefault: var.setdefault("var1":"a1")，如果key在字典中存在，则返回字典中的值，若不存在，则直接添加并返回这个新的值，和直接赋新值类型
- 遍历字典：for循环
- var.keys()
- var.values()
- var.items()，返回元组，使用解包分别返回key和value
- 定义元组
练习
'''
给列表做逆序操作：a = [1,2,4,5,6]
'''
a = [1,2,4,5,6]
_reverse = a.reverse()
print(a)
print(aa[-1::-1])
'''
实现学生管理系统：
1.记录学号，姓名，年龄
2.可以新增学生
3.可以列出所有学生
4.根据学号查找学生
5.根据学号删除学生
'''
s1 = {"id":31231,"name":"aa","age":12}
s2 = {"id":4324,"name":"vv","age":14}
sys = [s1,s2]
# print(sys)
s3 = {"id":453,"name":"ww","age":11}
sys.append(s3)
# print(sys)
for s in sys:
print(s["name"])
searchid = 453
for s in sys:
if s["id"]==searchid:
print(s["name"])
delid = 4324
for s in sys:
if s["id"]==delid:
d = sys.index(s)
del sys[d]
print(sys)5、函数
- 为什么使用函数？封装板块，封装重复的代码
- 定义函数：def 函数名(参数，可以为空):
- 调用函数：函数名()
- 函数参数：
- 形式参数：定义函数时指定的参数
- 实际参数：调用函数时传递进去的参数
- 位置参数：严格按照定义参数时的顺序传递参数,func(1,3)
- 关键参数：严格按照参数的名字传递参数，func(a=1,b=2)
- 混合参数：调用的时候既包括形式参数，也包括位置参数，位置参数必须在关键参数的前面，避免参数混淆
- *args和**kwargs：缺省位置参数和关键字参数。定义函数不知道会有多少位参数时，使用*args占位，数据类型为元组。**kwargs储存形式为字典类型。位置需在关键参数之前。
- 默认参数：定义函数时候，直接赋值给一个形式参数，如果调用的时候没有传递该参数，就会使用定义函数时候赋的值。func(a,b,c=100)，默认参数只能在其他参数后面，但是在缺省参数之前。
- 函数返回值：return
- 局部变量：在函数中的变量，不能在外部使用
- 全局变量：在整个当前python文件中都可以使用
- global关键字：如果想在函数中，或某个代码块中修改全局变量，可以使用global关键字修改。 global var
- 对于可变数据类型，如列表、字典：如果在定义函数时想要改变变量的值，重新指向一个值，即用”=“赋值，需要使用global var先声明，否则只会在在函数中生成一个局部变量。但是对于可变数据类型，增删查改的操作不需要声明global，全局变量也会相应的更改。
- sort函数：
- 相对复杂数据类型排序，如字典，使用自定义的规则来排序，针对两个内容及以上的。
-
from funtools import cmp_to_key def sorting(): xxxx a = dict() a.sort(key=cmp_to_key(sorting))
- 匿名函数：lambda表达式
- 定义方式：lambda x: x["var"]，简化代码的作用，适合只有一行代码的函数
- def funxtions_name(a,b,func): result = func(a,b) funxtions_name(2,1,lambda x,y:x+y)
- filter函数
- map函数
- reduce函数：from functools import reduce
a = [1,2,3,4,5,6]
r = filter(lambda x:True if x<=3 else False,a)
for x in r:
print(x)
def adding(a,b):
return a+b
print(adding(12,32))
def adding2(*args):
s = 0
for i in args:
s += i
return s
aa = adding2(1,2,3,4,5,6,7,8,9,10)
print(aa)6、文件
- 文件基本操作：
- 打开文件：open('file_name.ext','w')，以写的方式打开文件
- 在文件中操作：var.write("sdadsadsa")
- 关闭并保存文件：var.close()
- 打开文件的默认编码，打开的模式：
- open('file_name.ext','r')，open('file_name.ext','r',encoding = 'utf-8')，以读的方式
- open('file_name.ext','w')，以写的方式
- python2默认使用utf-8编码，python3若没有指定编码，将使用默认指定的编码
- open('file_name.ext','a')
- open('file_name.ext','r+')
- open('file_name.ext','w+')
- open('file_name.ext','rb)
- 文件读取的方式：
- var.read()，var.read(number)
- var.readline()
- var.readlines()，如果文件内容太多，会影响内存
- 大文件读取方式：
- 遍历文件指针对象：直接使用for循环遍历文件
- 文件写入操作：
- var.write()
- var.writelines()，不会换行
- 文件定位操作：
- 文件指针，即光标
- var.tell()，获取光标所在的位置（即指针所在位置）
- var.seek(offset,from)
- with语句优化文件操作：因为如果使用close会容易忘记， 漏掉后文件无法保存，可以使用with语句来优化操作。with open() as var:
练习：（还需要研究exit()模块，如果再次打开文件，怎么判断）
info = []
try:
with open('student.txt','r',encoding='utf-8') as fp:
for line in fp:
line.split('/')
_id = line[0]
_name = line[1]
_age = line[2]
_dic = {"id":_id,"name":_name,"age":_age}
info.append(line)
except FileNotFoundError:
fp = open('student.txt','r',encoding='utf-8')
fp.close()
def adding():
_id = input('id:')
_name = input('name:')
_age = input('age:')
_list = {"id":_id,"name":_name,"age":_age}
info.append(_list)
print(info)
def listing():
for line in info:
print(line)
def searching():
_search = input("who are you looking for?")
for line in info:
if line['name'] == _search:
print(line)
def exit():
with open('student.txt','w',encoding='utf-8') as fp:
_write = []
fp.tell()
for i in info:
_string = "{id}/{name}/{age}".format(
id=i['id'],
name=i['name'],
age=i['age']
)
_write.append(_string+'\n')
fp.writelines(_write)
def main():
print('*'*30)
print('1.adding new student:')
print('2.List all students:')
print('3.Search student via id:')
print('4.exit')
print('*'*30)
# choose = input('plese input your selection:')
while True:
choose = input('plese input your selection:')
if choose == '1':
adding()
elif choose == '2':
listing()
elif choose == '3':
searching()
elif choose == '4':
exit()
break
else:
choose = input('Invalid chosse, plese input your selection again:')
main()7、面向对象
- 面向过程和面向对象的区别？面向对象的思考方式更符合大众的思考方式，面向对象的编程方式将相同的类打包，其中可以包含不同的属性，代码更灵活。定义一个对象时，只需要从类中定义。class Person(object): def _init_(self,name,age): xxx def run(self):xxx var = Person() var.run()
- 类和对象的基本使用：
- 类：
- class _NAME(object): def function(self): ，规定类中的所有方法都必须以"self"为第一个参数传输进去。
- 对象：对象是对类的实例化，
- var = class(), var.fucntion()
- 也可以任意给定义的对象一些自定义属性，如var.name="ahsdh", var.age = 19，但最好在类中使用构造函数（或初始化函数）定义属性
- 初始化函数：def _init_(self, attr1,attr2,attr3...)
- id() 函数显示唯一地址
- 类：
- 访问限制：
- 受保护的属性或方法，使用下划线开头： self._name = "aaa",
- 私有属性或方法，使用双下划线开头，外部绝对不能访问，比如密码
- 私有的方法的意义？不能被外部调用，但是能在类中使用。即不能print出来
- 但如果实在需要调用私有的，var . _class__attri来调用，在协同开发时，不能强制调用，遵守开发规则。
- 析构函数和引用计数
- 析构函数：__del__：只要这个对象在内存中即将被消灭时，就会调用这个方法。
- 引用计数：python中的对象时使用引用计数的方式实现的，即如果没有任何一个对象引用到一块内存时，那么python就会把这块内存回收。
- sys.getrefcount(object)：获取一个对象的引用计数
- 继承：class Person(object): xxx class p1(Person)，那么类p1继承了类Person里面所有的属性和方法。调用顺序是先去找子类的，然后再去找父类中的。
- 重写父类方法：有时父类的方法不适合子类的，这时想要重新写父类的方法。在子类中重写父类的方法。 def __init__(self,name,age): super(Student,self).__init__(name.age)。使用super函数调用父类的方法。
- 子类不能继承父类的私有变量
- 新式类和旧式类：
- 旧式类：在python2.2版本之前，没有指定任何父类。class Person():xxx，子类中不能使用super函数来调用父类函数，必须重新写__init__
- 新式类和旧式类的类型不一样。新式类的类型表述更加准确。旧式类的类型是"instance"
- 多继承问题：
- 可以使用__mro__函数查看多继承的调用顺序
- 多态：多个子类，调用的时候不需要强制数据类型
- 类属性和实例属性：
- 实例属性：绑定到对现象上的属性是实例属性，p1=Person()，只在当前对象上有作用。
- 类属性：在类中定义的变量，对象也可以调用。可以通过对象的方式访问，也可以使用类的方式访问，但后者更佳。因为如果通过对象访问，只是在对象中新增了一个属性。
- 类方法和静态方法：
- 类方法：在类中使用@classmethod，并且括号中的参数写成class(cls)，使其变成类方法，在外部调用的时候可以直接使用类名调用，如Person.eat()
- 静态方法：在类中使用@staticmethod，不需要传递类和对象。原因是这个静态函数可以理解为仅是一个普通函数，只是绑定在了类方法中
- __new__方法：
- def __new__(cls,*args,**kargs): prtint() return super().__new__(cls)，
- 必须返回父类的调用，否则是none
- 如果父类是object，那么__new__方法的时候就不能传递cls以外的参数了
- python创建单例对象：
- 在某个程序中，某个类的对象只有一个
- __doc__：可以使用这个方法看到注释
练习
'''
1、添加宠物
2、显示所有宠物
3、宠物信息用文件储存
4、用面向对象的方式实现
不适用面向过程的方法，使用面向对象的方法。
类可以分为(架构)：宠物信息保存类-->宠物管理类（增删查改）-->程序管理(空值程序运行流程)
'''
class Pet(object):
'''
宠物类
'''
def __init__(self,pet_id,pet_name,pet_type,pet_price):
self.id = pet_id
self.name = pet_name
self.type = pet_type
self.price = pet_price
@classmethod
def pet_with_line(cls,line):
pet_id,pet_name,pet_type,pet_price = line.replace('\n','').split('&')
pet = Pet(pet_id,pet_name,pet_type,pet_price)
return pet
# print(Pet.__doc__)
'''
宠物管理系统只需要存在一个，定义为一个单例对象，重写new方法
'''
class PetManager(object):
__instance = None #单例对象，比如登录一个程序只使用自己的用户名
__filename = 'pet.book.txt'
def __new__(cls,*args,**kargs): ##因为不知道父类会传递什么参数进来，所以使用args
#如果在某个地方单例对象以及存在，那么久返回当前的，如果不存在，那么就新创建一个
if not cls.__instance:
cls.__instance = super(PetManager,cls).__new__(cls,*args,**kargs)
return cls.__instance
def add_pet(self,pet_id,pet_name,pet_type,pet_price):
pet = Pet(pet_id,pet_name,pet_type,pet_price) #定义宠物的一个对象
with open(PetManager.__filename,'a') as fp:
line = "{id}&{name}&{type}&{price}\n".format(id = pet_id,name=pet_name,type=pet_type,price=pet.pet_price)
fp.write(line)
def list_all_pets(self):
all_pets = []
with open(PetManager.__filename,'r') as fp:
for line in fp:
#初始化一个对象回来
pet = Pet.pet_with_line(line)
all_pets.append(pet)
return all_pets
calss Application(object):
__instance = None
def __new__(cls,*args,**kargs):
if not cls.__instance:
cls.__instance = super(Application,cls).__new__(cls,*args,**kargs)
return cls.__instance
def __input_pet_info(self):
pet_id = input('id:')
pet_name = input('name:')
pet_type = input('pet_type:')
pet_price = input('pet_price:')
manager.add_pet(pet_id,pet_name,pet_type,pet_price)
print("sunccessfully added!")
def __print_all_pets(self):
all_pets = manager.list_all_pets()
for pet in all_pets:
print(pet)
def run(self):
while True:
option = input("Please input your option:")
if option =='0':
break
elif option == '1':
self.__input_pet_info()
elif option == '2':
self.__print_all_pets()
def main():
manager = PetManager()
app = Application()
app.run()
if __name__ == '__main__':
main()TO BE CONTINUED...
5974
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
