第一天
如果看不懂 可以考虑直接从第三天开始看
懂一部分也可 不碍事
python是一门 动态的 强类型语言
类型检查：查看变量和它们的类型 判断表达式是否合理
动态语言：如果类型检查发生在程序运行阶段 那么它便是动态类型语言
静态语言：类型检查发生在编译阶段
强类型语言：不管在编译阶段还是运行阶段 一旦某种类型绑定到变量后 该变量就会持有这个类型 并且不能同其他类型在计算表达式时混合使用
弱类型语言：容易发生不同类型混合计算
四大基本语法
命名规则
- 允许包容英文 数字 下划线 不能以数字开头
- 名称区分大小写
补充说明
1 类变量若以单下划线开头 代表不能直接被访问 不能通过 import module_name而导入
2 类变量若以双下划线开头表示为类的私有成员 不能被导入和其他类变量访问
3 以双下划线开头和双下划线结尾的变量有特殊身份
python变量的命名习惯
遵循蛇形命名法
- 一般变量命名 book_id book_store_count
- 类名首字符大写
- 类方法名 get_store_count();
- 其他特殊变量 全部大写
缩进原则
缩进的层级代表逻辑层次 代替了大括号的作用
特殊关键字
False await else import pass
None break except in raise
True class finally is return
and continue for lambda try
as def from nonlocal while
assert del global not with
async elif if or yield
特殊运算符
我觉得正常的运算符大家都知道
这里只介绍3个特殊的运算符
// ** :=
//代表数值相除 向下取整
5//2=2
5//4.5=1.0
**用于幂运算
2**3=8
:=是py3.8里的海象运算符
n = len(a)
if n > 10:
print(f"{n}大于10")
可以写成
if ( n := len(a) ) > 10
print(f"{n}大于10")
老实说 我没看懂我教程的例子 先过xx
py还支持链式比较 比如
1<2<3
小结
python是一门 动态的 强类型语言
四大基本语法:命名规则 缩进原则 特殊关键字 特殊运算符
第二天
基本数值类型
数值型
py里一切皆对象
比如 int 对象 float双精度浮点型对象 bool逻辑对象
前缀加0x 创建一个16进制的整数
0xa5（165）
使用e创建科学计数法表示的浮点数
1.05e3（1050.0）
容器型
可以容纳多个元素的容器对象
比如list列表对象 tuple元组对象 dict字典对象 set集合对象
举例如下
lst=[1,2,3,4,5,6] （list变量）
tuple=(1,2,3,4,5,6)（tuple变量 补充：tup=(1,)含有单个元素的元组得多写个逗号才能被认为是元组 不然认为是元素本身了）
dic={‘a’:1,‘b’:3,‘c’:5}（dict变量 字典就是一个哈希表）
字符串
strip用于去除字用于符串前后的空格（包括回车）
replace用于字符串的替换
join用于合并字符串
title用于单词首字符大写
find用于返回匹配字符串的起始位置的索引
自定义类型
py使用关键字class来定义类
self表示类实例对象本身
一个自定义类内包括
- 属性
- 方法
其中 有些方法是自带的
class miao(object):
pass
以上定义了一个miao类 它继承于根类object
下面创建一个miao类型的实例：
miaomiao=miao()
miao类现在没有定义任何方法，但是它有自带的方法
可以使用__dir__()查看 如下
class miao(object):
pass
miaomiao=miao()
print(miaomiao.__dir__())
输出如下
['__module__', '__dict__', '__weakref__', '__doc__', '__repr__', '__hash__', '__str__', '__getattribute__', '__setattr__', '__delattr__', '__lt__', '__le__', '__eq__', '__ne__', '__gt__', '__ge__', '__init__', '__new__', '__reduce_ex__', '__reduce__', '__subclasshook__', '__init_subclass__', '__format__', '__sizeof__', '__dir__', '__class__']
以上方法又叫魔法方法
它们与创建类自定义个性化行为有关 比如
getattribute 方法自定义读取属性的行为
setattr 自定义赋值与修改属性时的行为
init 方法能定义一个带参数的类
new 方法自定义实例化类的行为
类的属性
class miao(object):
pass
miaomiao=miao()
def __init__(self,name,dtype):
self.name=name
self.dtype=dtype
__init__(miao,'123','cute')
print(miaomiao.dtype)
我可以通过这个函数 来实现给类miao加两个属性 name和dtype
然后输出一下 发现成功了
类的实例
miaomiao就是实例
(待补充)
类的方法
(待更新)
对于初学者来说不必纠结 学到后面就能理解
第三天
list和tuple的基本操作
深浅拷贝和切片操作等5个方面总结
列表
列表：作为py中最常用的数据类型之一 是一个可增删元素的可变容器
基本操作
创建list的办法如下
empty = []
lst = [1,'jcc',36.5,'114514']
lst2 = ['jcc','2020-8-5',['猫猫','喵喵']]
py内置函数len可以求元素个数 如果你这样敲（如下）
print(len(empty),len(lst),len(lst2))
就会显示
0 4 3
依次遍历求对应类型可以用内置函数type这样敲（如下）
for _ in lst2:
print(f'{_}的类型为{type(_)}')
结果为
jcc的类型为<class 'str'>
2020-8-5的类型为<class 'str'>
['猫猫', '喵喵']的类型为<class 'list'>
由此也能看出py的列表元素类型可以不一致
lst2.append("烤鸭")
可以增加元素 append默认增加到sku列表尾部
运行刚刚的代码多出来的结果为
烤鸭的类型为<class 'str'>
还可以插入 靠insert 方法如下
lst2.insert(1,"牛肉")
打印结果如下
jcc的类型为<class 'str'>
牛肉的类型为<class 'str'>
2020-8-5的类型为<class 'str'>
['猫猫', '喵喵']的类型为<class 'list'>
烤鸭的类型为<class 'str'>
如果想移除列表尾部元素可以用pop
lst2.pop()
还可以移除目标值的元素 用remove
lst2.remove('2020-8-5')
深浅拷贝
深拷贝例子如下 输出False
from copy import deepcopy
a=[1,2,[3,4,5]]
ac=deepcopy(a)
ac[2][1]=40
print(a[2][1]==ac[2][1])
浅拷贝例子如下 输出True
a=[1,2,[3,4,5]]
ac=a.copy()
ac[2][1]=40
print(a[2][1]==ac[2][1])
如果改变不嵌套的元素
浅拷贝和深拷贝都会成功 因为本质在不同的空间
切片
a = list(range(1,20,3))
print(a)
输出结果为[1, 4, 7, 10, 13, 16, 19]
如果使用a[:3]获取a的前三个元素 这种做法就叫切片 切片本身也是一个列表
- a[-1]获取a的最后一个元素 a[:-1]获取除最后一个元素的切片
- 使用a[1:5] 生成[1,5)的切片
- 使用a[1:5:2]生成[1,5)且步长为2的切片
- 使用a[::3]生成索引[0,len(a))步长为3的切片
- 使用a[::-3]生成逆向索引[0,len(a))步长为3的切片
通过逆向切片实现列表逆向操作
def reverse(lst):
return lst[::-1]
列表到这里差不多就说完了
元组
元组是不可变对象 没有增删元素的方法
a = ()
b = (1,'xiaoming',29.5,'17312662388')
c = ('001','2019-11-11',['三文鱼','电烤箱'])
这全是元组 和列表像 除了元组创建方法不同
特别注意：一个特殊情况
(1)这是一个整数
(1,)这才是一个元组
列表与元组都可以这样统计
from numpy import random
a = random.randint(1,5,10)
# 从 [1,5) 区间内随机选择 10 个数
at = tuple(a)
# 转 tuple：(1, 4, 2, 1, 3, 3, 2, 3, 4, 2) 转list也可
t=at.count(3)
# 统计 3 出现次数，恰好也为 3 次from numpy import random
print(t)
可变与不可变
列表可变 可以增删 可以插入
元组不可变 指的是长度不变
举个例子 如果一个元组里有一个元素是列表 就算改变了这个元组的列表 也不会影响元组的长度 不可变主要是指这个
第四天
list和tuple的经典使用案例（12个）
1 判断列表里有没有重复元素
def is_duplicated(lst):
for x in lst:
if lst.count(x) > 1: # 判断 x 元素在 lst 中的出现次数
return True
return False
lst=[1,2,3,4]
print(is_duplicated(lst))
或者 下面的 靠集合来实现
def is_duplicated(lst):
return len(lst) != len(set(lst))
lst=[1,2,3,4]
print(is_duplicated(lst))
2 列表反转
[::-1]本身是一个切片操作
[::-1]又代表逆向索引 所以。。
def f(lst):
return lst[::-1]
lst=[1,2,3,4]
print(f(lst))
3 找出列表中所有重复的元素
def find_duplicate(lst):
ret = []
for x in lst:
if lst.count(x) > 1:
ret.append(x)
a=set(ret)
return list(a)
lst=[1,2,3,3,4,4,5,6,7,7,7,1,10,10,9,9]
print(find_duplicate(lst))
如果你在意这会导致排好序 导致格式问题 那我只能说
我们的目的不在于格式 而在于解决问题本身
def find_duplicate(lst):
ret = []
for x in lst:
if lst.count(x) > 1:
ret.append(x)
a=set(ret)
return list(a)
lst=[1,2,3,3,4,4,5,6,7,7,7,1,10,10,9,9]
print(find_duplicate(lst))
掌握了思维方法 想要列表格式一样可以靠上面的代码完成
4 斐波那契数列
def fibonacci(n):
if n <= 1:
return [1]
fib = [1, 1]
while len(fib) < n:
fib.append(fib[len(fib) - 2] + fib[len(fib) - 1])
return fib
print(fibonacci(10))
def fibonacci(n):
if n <= 1:
return [1]
fib = [1, 1]
a=0
b=1
while len(fib) < n:
fib.append(fib[a] + fib[b])
a+=1
b+=1
return fib
print(fibonacci(10))
都随意
5 求出现频率最多的元素
def f(lst):
max_num=max(lst,key=lambda v:lst.count(v))
cs=lst.count(max_num)
res=[]
for x in lst:
if x not in res and lst.count(x)==cs:
res.append(x)
return res
t=[1,2,3,5,5,5,6,6,6]
print(f(t))
如果你看不懂lambda 请查阅下资料 加油
6 求最长list
def f(*lis):
return max(*lis,key=lambda v:len(v))
lst1=[1,2,3,4,5]
lst2=[1,2,3,4,5,6,7,8]
lst3=[1,2,3,4,5,6,7]
print(f(lst1,lst2,lst3))
7 求表头 表尾
def head(lst):
return lst[0] if len(lst)>0 else None
lst1=[]
print(head(lst1))
def tail(lst):
return lst[-1] if len(lst)>0 else None
lst1=[]
print(tail(lst1))
简洁表达
8 乘法表
for i in range(1,10):
for j in range (1,i+1):
print("%d*%d = %d"%(j,i,i*j),end=" ")
print("\n")
9 元素对
def pair(t):
return list(zip(t[:-1],t[1:]))
print(pair(range(6)))
这个仔细想想 查查zip 多想一会儿就能懂 蛮巧妙的
10 样本抽样
from random import randint,sample
lst = [randint(0,50) for _ in range(100)]
# randint 生成随机整数；
lst_sample = sample(lst,10)
# sample 从 lst 中抽样 10 个元素
print(lst_sample)
11 重洗数据集
from random import randint,sample,shuffle
lst = [randint(0,50) for _ in range(100)]
print(lst[:5])
shuffle(lst) # 重洗数据
print(lst[:5])
12 生成满足条件的点
from random import uniform
x, y = [i for i in range(100)], [
round(uniform(0, 10), 2) for _ in range(100)]
print(y)
from pyecharts.charts import Scatter
import pyecharts.options as opts
from random import uniform
def draw_uniform_points():
x, y = [i for i in range(100)], [
round(uniform(0, 10), 2) for _ in range(100)]
print(y)
c = (
Scatter()
.add_xaxis(x)
.add_yaxis('y', y)
)
c.render()
draw_uniform_points()
第五天
dict和set基本操作 字典视图等方面的总结
字典
一种映射对象类型的键值对容器
字典基本操作
1 创建字典 字典的五种创建方法
empty = {}
dic1 = {'a':1,'c':3,'e':5}
dic2=dict(a=1,b=2,c=3)
dic3=dict({'a':1,'b':2},c=3,d=4)
dic4=dict([('a',1),('b',2)],c=3)
dic5={}.fromkeys(['k1','k2','k3'],[1,2,3])
dic6={'a':1,'b':2}.fromkeys(['c','d'],[1,2])
print(empty,"\n",dic1,"\n",dic2,"\n",dic3,"\n",dic4,"\n",dic5,"\n",dic6)
结果如下
{}
{'a': 1, 'c': 3, 'e': 5}
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
{'a': 1, 'b': 2, 'c': 3}
{'k1': [1, 2, 3], 'k2': [1, 2, 3], 'k3': [1, 2, 3]}
{'c': [1, 2], 'd': [1, 2]}
2 遍历字典
就拿上面的字典举例吧
dic1遍历如下
for key, val in dic1.items():
print(key,val)
结果为
a 1
c 3
e 5
dic5遍历如下
for key, val in dic5.items():
print(key,val)
结果为
k1 [1, 2, 3]
k2 [1, 2, 3]
k3 [1, 2, 3]
3 获取所有键集合（keys）
方法1
print(set(dic1))
结果为
{'c', 'e', 'a'}
方法2
print(set(dic6.keys()))
结果为
{'d', 'c'}
4 获取所有值集合（values）
print(set(dic1.values()))
{1, 3, 5}
这里是没法获取dic5/6的值集合的 会报错
5 获取某键对应的值
d=dict(a=1,b=2,c=3)
if 'c' in d:
print('键c在字典d中')
if 'e' not in d:
print('键e不在字典d中')
print(d.get('c'))
6 添加、修改或删除一个键值对
d['d'] = 4
print(d)
d['d'] = 5
print(d)
del d['d']
print(d)
d.pop('c')
print(d)
字典视图
字典自带的三个方法
d.items()、d.keys()、d.values()
d = {'a': 1, 'b': 2, 'c': 3}
print(d.keys(),"\n",d.values(),"\n",d.items())
输出如下
dict_keys(['a', 'b', 'c'])
dict_values([1, 2, 3])
dict_items([('a', 1), ('b', 2), ('c', 3)])
补充：不可哈希的对象不能作为字典的键
比如列表就不行 因为列表是可变对象 可变对象不可哈希
集合
一种不允许元素出现重复的容器
判断一个列表中是否含有重复元素 可借助集合这种数据类型
def duplicated(lst):
return len(lst)!=len(set(lst)) #长度不等就是重复了
创建
与字典（dict）类似 集合（set）也是由一对花括号“{}”创建
a = {1, 2, 3}
b=set([1,3,5,7])
print(a,b)
输出
{1, 2, 3} {1, 3, 5, 7}
同字典类似 集合内的元素必须是可哈希类型（hashable）
这就意味着 list dict 等不可哈希的对象不能作为集合的元素
增加（更新）元素set.add() set.update([])
a = {1, 2, 3}
b=set([1,3,5,7])
a.add(4)
b.update(["123"])
print(a,b)
删除元素 set.remove( )
a = {1, 2, 3}
b=set([1,3,5,7])
a.add(4)
b.update(["123"])
a.remove(4)
b.remove("123")
print(a,b)
没法改和查
交集 并集 差集
交集
nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#交的方式一：&
a = nums1&nums2
print(a)
#并的方式二：intersaction
b = nums1.intersection(nums2)
print(b)
{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}
并集
nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#并的方式一：|
a = nums1|nums2
print(a)
#并的方式二：uniom
b = nums1.union(nums2)
print(b)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
差集
nums1 ={1, 2, 3, 4, 5, 6}
nums2 ={1, 2, 3, 4, 5, 10,7,8,9}
#差的方式一：-
a1 = nums1-nums2
print(a1)
a2 = nums2-nums1
print(a2)
#差的方式二：difference
b1 = nums1.difference(nums2)
print(b1)
b2 = nums2.difference(nums1)
print(b2)
{6}
{8, 9, 10, 7}
{6}
{8, 9, 10, 7}
把集合变成其他东西
se = set(range(4))
li = list(se)
tu = tuple(se)
st = str(se)
print(li,type(li))
print(tu,type(tu))
print(st,type(st))
[0, 1, 2, 3] <class 'list'>
(0, 1, 2, 3) <class 'tuple'>
{0, 1, 2, 3} <class 'str'>
第六天
dict和set的？个实例(其实还是语法练习x 也许会混杂别的）
实际使用字典时 需要批量插入键值对到已有字典中
1 update 方法实现批量插入 例子如下
d = {'a': 1, 'b': 2}
d.update({'c':3,'d':4,'e':5})
print(d)
输出
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
2 如果字典中没有某个键值对 就插入到字典里有的话 就不插入 如下代码
d={'a':1,'b':2}
r=d.setdefault('c',3)
r=d.setdefault('c',33)
print(d)
3 求字典并集
如下
def f(d1,d2,d3):
return {**d1,**d2,**d3}
d1=dict(a=1,b=2)
d2=dict(c=3,d=4)
d3=dict(e=5,f=6)
print(f(d1,d2,d3))
print(dict(**d1, **d2))#这样理解更直观
4 按键排序
def sort_by_key(d):
return sorted(d.items(), key=lambda x: x[0])
a=dict(a=3,d=2,c=1)
print(sort_by_key(a))
5 字典差
def difference(d1, d2):
return dict([(k, v) for k, v in d1.items() if k not in d2])
print(difference({'a': 1, 'b': 2, 'c': 3}, {'b': 2,'d':3 }))
6 按值排序
def sort_by_value(d):
return sorted(d.items(), key=lambda x: x[1])
x=dict(a=1,b=7,c=6,d=3)
print(sort_by_value(x))
7 找最大键
def max_key(d):
if len(d)==0:
return []
max_key = max(d.keys())
return (max_key,d[max_key])
a=dict(a=1,b=7,d=9,z=10)
print(max_key(a))
8 最大字典值
def max_key(d):
if len(d)==0:
return []
max_val = max(d.values())
return [(key,max_val) for key in d if d[key]==max_val] #找到是最大值的键
a=dict(a=1,b=11,c=11,d=11)
print(max_key(a))
9 找集合最值随便输出（格式随意）
def max_min(s):
return (max(s),min(s))
a={1,7,11,2,6,4}
print(max_min(a))
10 判断单字符串（无重复字符的字符串）
def f(string):
return len(set(string))==len(string)
a="1234561"
print(f(a))
11 找更长集合
def longer(s1,s2):
return max(s1,s2, key=lambda x: len(x))
a={1,3,5,7,9}
b={3,3,3,3,3,3,3,3,3}
print(longer(a,b))
12 寻找列表中重复的元素 默认只返回（凑数？ 复习√）
def max_overlap(lst1,lst2):
overlap = set(lst1).intersection(lst2)#交集2 3
ox = [(x,min(lst1.count(x), lst2.count(x))) for x in overlap] # 2 4 3 2
return max(ox, key=lambda x: x[1])
a=[1,2,2,2,2,3,3,2,3]
b=[2,2,3,2,2,3]
print(max_overlap(a,b))
3038
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
