莫凡python基础
day1
1.print()
若定义自变量，不需要引号即可输出
apple=1
print(apple)
一些常见使用方式
print("") = print('')
print('apple'+'car') # applecar
print('apple','car') # apple car
print(1+2) # 3
print(int(1)+2) # 3
2.平方如何实现：
不采取^符号和pow函数
32
22
3.while 循环与C语言类似
4.for
不需要提前定义，但需要非常注重语言形式、结构、推进
range(1,10) ->1,2,3,4,5,6,7,8,9 含头不含尾
range(1,10,2) ->1,3,5,7,9 步长为2
5.if
以下两种格式都可以实现
相当于中间的y替换成y&&y
if x>y>z:
if x>y<z:
if x>z:
print
elif x>y:
print
else:
print
6.fun(a,b)
def fun(a,b):
对于里面参数，可以提前确定 如：
def sale(money,color="blue",brand="bmw",Is_Second)
也可以后续确定
def sale(money,color,brand,Is_Second)
但要保证确定好的值不能放在前面如：
def sale(money,color="blue",brand,Is_Second)
brand此时应该放在color前面
7.文件读写；
如何写：
open(name='myfile.txt' mode='w' encoding='cp936'>)
如何读：
file=open("myfile.txt","r")
content=file.read()
print(content)
或者采取逐行读取：
file.readlins -->逐行读取，读取行数
day2
1.Class类
class Calculator:
name = 'fu'
price = 18
def __init__(self): # 初始化 给予基本属性
print("welcome = {}".format("fu"))
def addzxc(self, x, y):
print(x + y)
def minuszxc(self, x, y):
print(x - y)
def dividezxc(self, x, y):
print(x / y)
def timeszxc(self, x, y):
print(x * y)
# 创建一个类jisuanqi，它是类calculator()的子类
class jisuanqi(Calculator): # 正常来讲 应该是 jisuanqi()或者（objective）
name = "zi"
def __init__(self):
print("welcome = {}".format("zi"))
# 面向对象，生成一个对象 calcul
calcul = Calculator() # ->初始化运行后输出welcome = haha
print(calcul.name) # ->输出名字 fu
calcul.addzxc(1, 2) # ->输出3
# 对于子类 可以使用父类中的一些函数，继承
jisuan = jisuanqi() # ->子类输出 welcome =zi
print(jisuan.price) # ->输出名字 18
print(jisuan.name) # ->输出名字 zi
jisuan.minuszxc(1, 2) # ->输出-1
# 对于init函数
class fish:
def __init__(self, name, price, height, width, weight):
self.name = name
self.price = price
self.h = height
self.wi = width
self.we = weight
# C=fish() #会报错 缺少 5 required positional arguments: 'name', 'price', 'height', 'width', and 'weight'
C = fish("xixixi", 28, 4, 5, 6)
print(C.name) # 输出xixixi
print(C.price) # 输出28
# 以上的适合自行初始化，相当于人为输入进去一些属性
# 也可以直接定好,不允许更改 例如：
class dog:
name = 26
price = 27
def __init__(self, height, width, weight):
self.h = height
self.wi = width
self.we = weight
d = dog(11, 22, 33)
print(d.name)
print(d.price)
# 或者结合上一节所学,把固定好的放后面：
# 需注意的是，此时需额外添加self.()进行声明
class cat:
def __init__(self, height, width, weight, name=13, prince=12, ):
self.h = height
self.wi = width
self.we = weight
self.name = name
self.price = prince
c = cat(1, 2, 3)
print(c.name)
print(c.price)
print(c.h)
2.input函数
# 对于input函数
a_input = input('please give a number\n')
if a_input == 1 :
print("you're right")
elif a_input == 2 :
print("see you next time")
else:
print("good luck")
# 当你输入1，结果是good luck ，为什么不会显示you are right?
# 问题出现在返回值是一个str类型字符串，不是int整数型
# 解决的方法有俩种：
# 1.采取a_input == '1'
# 2.采取int强制类型转换 a_input = int(input('please give a number\n'))
day3
元组
# 对于元组，不可被修改，但也有好处：
# Python的函数返回多值时，其实就是返回一个tuple。
# 相对于 list 而言，tuple 是不可变的，这使得它可以作为 dict 的 key，或者扔进 set 里，而 list 则不行。
a_tuple = (12, 3, 6, 123, 23)
another_tuple = 2, 5, 6, 7, 2
a_list = [12, 44, 213, 234]
# 需注意 从0开始
for index in range(len(a_tuple)):
print("index=", index, "list[index]=", a_tuple[index])
# 对于列表
a = [1, 2, 6, 2, 5, 76, 7]
a.append(8) # 在末尾添加数字8 ->[1, 2, 6, 2, 5, 76, 7, 8]
a.insert(1, 22) # 在1位置添加22 列表的第0位是1，第一位是2 ->[1, 22, 2, 6, 2, 5, 76, 7, 8]
a.remove(2) # 除掉第一个2 -> [1, 22, 6, 2, 5, 76, 7, 8]
print(a) # [1, 22, 6, 2, 5, 76, 7, 8]
print(a[-1]) # 输出最后一位 8
print(a[0:3]) # [1, 22, 6] 只会输出0 1 2 位 不会到第三位
print(a[5:]) # [76, 7, 8]
print(a[-4:]) # [5, 76, 7, 8]
print(a.index(2)) # 3 在[1, 22, 6, 2, 5, 76, 7, 8]占第三位
print(a.count(2)) # 1 在[1, 22, 6, 2, 5, 76, 7, 8]出现一次
a.sort()
print(a) # [1, 2, 5, 6, 7, 8, 22, 76]
a.sort(reverse=True)
print(a) # [76, 22, 8, 7, 6, 5, 2, 1]
# 多维列表
a = [1, 2, 3, 4, 5, 6]
b = [[1, 2, 3, 4, 5, 6]]
multi_dim_a = [
[1, 2, 3],
[2, 3, 4],
[3, 4, 5]
]
# 完整打印会显示什么？
print(a) # [1, 2, 3, 4, 5, 6]
print(b) # [[1, 2, 3, 4, 5, 6]]
print(multi_dim_a) # [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
# 打印某行某列呢？
print(a[1]) # 2 从0开始
print(b[0]) # 打印第b[1]会报错，说明为1行6列 ，只打印第0行了
print(multi_dim_a[0]) # [1, 2, 3]
print(multi_dim_a[0][2]) # 3 前面为行，后面为列
# 字典
a_list = [1, 2, 3, 4, 5, 6, 73, 3]
d = {
'apple': 1, 'pear': 2, 'orange': 'haha'
}
# 另一种表达形式：
d2 = {1: 'a', 'c': 'b'}
# 先观察能打印什么
print(d)
print(d2)
print(d['apple']) # 1
print(d['orange']) # haha
# print(d[1]) 会报错 而下面操作则不会
print(d2[1])
print(d2['c'])
# 因此，只能找冒号前面的项进行查阅
# 若想对字典其进行操作
del d['pear'] # 删除pear 这种方法 del.d['orange'] 不行
d['apple'] = 20 # 修改值 从1->20
d['b'] = 399 # 添加，不用管顺序 {'apple': 20, 'orange': 'haha', 'b': 399}
d['zxc'] = d2 # 嵌套 {'apple': 20, 'orange': 'haha', 'b': 399, 'zxc': {1: 'a', 'c': 'b'}}
print(d)
print(d['zxc'][1]) # 找具体也可通过顺序查找，最后得到a
模块
# 第一种：最直接，最常用
import time
print(time.localtime())
# 第二种：若模块名字太长，可代换名字
import time as t
print(t.localtime())
# 第三种：从一个模块里面导入一些功能，不需要全部
from time import localtime, time
print(localtime()) # 这个时候就不用直接time.localtime()
print(time())
# 第四种：导入所有功能，也不需要输入time.
from time import *
# 可由以下理解：
# import 模块：导入一个模块；注：相当于导入的是一个文件夹，是个相对路径。
# from…import：导入了一个模块中的一个函数；注：相当于导入的是一个文件夹中的文件，是个绝对路径。
# import 导入模块，每次使用模块中的函数都要是定是哪个模块。
# from…import * 导入模块，每次使用模块中的函数，直接使用函数就可以了；注因为已经知道该函数是那个模块中的了。
#如果想导入自己的模块：
# 1.先建立新文件.py
# 2. def实现函数
# 3.主文件中进行导入使用
# continue try break
# continue :在一个循环里，跳出这个循环，重新进行循环判断
# break: 直接跳出循环 不做介绍
try:
file = open("zxczxc", 'r+')
except Exception as e:
print(e) # 将错误保存，并打印出现结果：[Errno 2] No such file or directory: ''
resp = input("do you wanna create a new file?\n plz answer y or n\n")
if resp == 'y':
file = open("zxczxc", 'w+')
else:
pass
else: # 如果try成功了，则直接运行这个，不经过except
file.write("ssssasd")
text = file.read()
print(text)
file.close()
# 需注意的是，r+会覆盖文件，因此重复运行不会叠加
# 若采用a+呢？观察后发现，不会覆盖。
# zip功能：从俩个数组中依次抽取一个元素组成新的元组，例如：
a = [1, 2, 4, 5]
b = [1, 5, 3, 2]
c = zip(a, b)
print(list(c)) # [(1, 1), (2, 5), (4, 3), (5, 2)]
print(type(c)) # <class 'zip'>
for i, j in zip(a,b):
print(i, j)
d = zip(a,a,b) # 也可三者组合
print(list(d))
#若输入一个参数：
e = zip(a)
print(list(e)) # [(1,), (2,), (4,), (5,)]
# lambda python中的一类特殊的定义函数的形式，使用它可以定义一个匿名函数。
# 即当你需要一个函数，但又不想费神去命名一个函数，这时候，就可以使用 lambda了。
def fun1(x, y):
print(x + y)
fun2 = lambda x, y: x + y
print(fun2(2, 3))
# map :用于map() 会根据提供的函数对指定序列做映射。
# 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
c = map(fun2, [1], [2])
# print(c) #对象地址 <map object at 0x0000020F9C781E80>
print(list(c)) # [3]
d = map(fun2, [2, 4, 5], [1, 5, 7])
print(list(d)) # [3, 9, 12]
day4
import copy
a = [1, 2, 3]
b = a
print(id(a)) # 2237650380288
print(id(b)) # 2237650380288
# 两个id一模一样，相当于索引绑在一起，同一个内存空间中
# 改变一个值，另一个也跟着改变，可以简单理解成为占用一个空间。
a[0] = 555
print(b) # [555, 2, 3]
b[2] = 23232
print(a) # [555, 2, 23232]
# 若采用copy浅复制
c= copy.copy(a)
print(id(a)==id(c)) # False
# 此时改变c，a不会被改变，如下：
c[1] = 245
print(a) # [555, 2, 23232] 不会改变a
# 浅复制后两者的id呢？如下：
a = [1,2,[3,4]]
d= copy.copy(a)
print(id(a)==id(d)) # false
print(id(a[2])==id(d[2])) # true
# 首地址竟然不同，但a[2]&d[2]地址居然相同，为什么会出现这种现象？b站上弹幕解释：
# 因为：copy只会复制父对象，而子对象是共用的；deepcopy完全复制所有的父对象和子对象
# 而deepcopy完全复制，内存地址和id都不会重复。
e = copy.deepcopy(a)
print(id(e[2])==id(a[2])) # false
# pickle
import pickle
a_dict = {'da': 111, 2: [23, 11, 45], '23': {1: 2, 'd': 'sad'}}
# 将上述字典保存下来， pickle.dump()将字典放入文件
# file = open('pickle_example.pickle','wb')
# pickle.dump(a_dict,file)
# file.close()
# 重新打开，并进行将其装载到a_dict1中
file = open('pickle_example.pickle', 'rb')
a_dict1 = pickle.load(file)
file.close()
print(a_dict1) # {'da': 111, 2: [23, 11, 45], '23': {1: 2, 'd': 'sad'}}
# set:类似列表和元组，但是里面的元素可不能重复
char_list = ['a', 's', 'b', 'b', 'd', 'c', 'c', 'd']
a_set = set(char_list) # 返回的是set类型的值，比较乱的排序 {'c', 's', 'd', 'b', 'a'}
print(a_set)
sentence = 'welcome back to this town'
b_set = set(sentence) # {'c', 't', 's', 'n', 'l', 'o', 'b', 'k', 'h', 'e', 'm', 'a', 'i', 'w', ' '}
print(b_set)
# set函数还有一些功能 如下：
unique_char = set(char_list)
unique_char.add('r') # 添加{'b', 's', 'c', 'r', 'd', 'a'}
# 再添加一遍r试试？
unique_char.add('r') # 结果不影响 {'b', 's', 'c', 'r', 'd', 'a'}
# unique_char.clear() #全部都清除了
unique_char.remove('b') # {'c', 's', 'r', 'd', 'a'}
print(unique_char)
# 判断俩者有无不同：
set1 = set(['a','b','c','d'])
set2 = set(['c','d','e','f'])
print(set1.difference(set2)) # 返回set1中没有交集的数据
print(set1.intersection(set2)) # 返回相同的地方
浙公网安备 33010602011771号