基于小甲鱼的php学习笔记

day01

1. type（xxx） 获取数据的类型

2. import rndom 导入一个模块

3. isinstance（xxx，类型） 判断前后两者的类型是否一样

4. 算数运算符 a+=1 a-=1
   地板除 10//8=1 10/8=1.25
   次幂 33=三的三次方 -33=-9
   先加减后惩处，先算括号里面的，再算括号外面的

5. 逻辑运算符： and or not
   幂》正负》算数》比较》逻辑

6. 三元操作符 small=x if 》y small=y

7. for xxx in xxxx ： 遍历

8. range(5) 产生五个数 0–4

9. break 跳出循环

10. continue 终止本次循环，开始下一次

列表—打了激素的数组

member=【‘鸡’，‘你’，‘太’，‘美’，1，2，3，4，5】
类似于c语言中的数组，但是这里的列表没有元素类型限制，任何类型的数据都可以放在同一个列表中，鱼龙混杂

万物皆类， 数组是一个类 列表是一个类，string也可以看作一个类，因此我们可以通过数据名.函数方法的方式来对指定函数进行调用
这里的member就绪=可以理解为列表类的一个实例化对象

1. member.append(123) 向列表中添加一个数据123
2. member.extend([1.3,4,5]) 用另外的一个列表来扩展这个列表
3. member.insert(1,2) 在指定的1位置插入一个2数据
4. member.remove(‘鸡’) 删除指定的元素
5. del member[1]
6. member.pop() 默认将最后面的那个元素提取出来
7. 列表分片 member[1:3] member.[:3]一次性提取多个元素
8. 列表之间的常见操作 list1+list2 将两个列表的元素进行拼接 1，2，3，4 5，6，7，8 ---------》1，2，3，4，5，6，7，8
   list1*3 将list1的元素复写三次
9. list2=【1，2，3，4，【5，6，7，8】，9】 对最里层的元素进行访问，要类比二维数组的方式

常见的dif lis.count(1) 返回1在列表中刚出现的次数
lis.indext(2) 返回2在列表中第一次出现的位置
lis.reserve() 将列表颠倒
lis.sort() 自动排序，默认是从小到大
访问方式：列表名【下标】 member【1】 member【2】

元组：带上了枷锁的列表

member=(‘1’,‘2’,‘3’,‘4’) /‘1’,‘2’,‘3’,‘4’

1. 和列表比较起来，元组不能够随意的更改
2. 访问方式 元组名[下标]
3. 可以利用分片的方式来进行元组元素的新增 member1=member1【：3】+【5，】+member【3:】
   元组和列表很相似，只是元组的元素无法随意更改

字符串

string=‘i love you’
访问方式同上

格式化：“{0} {1} {2}.com”format（“i“，”love“，”you“） --------》i love you.com
“{a} {b} {c}.com”format（a=“i“，b=”love“，c”you“） --------》i love you.com
常见的字符串格式化字符 %c %d %s %o…

内置bif

c=list（） 列表转换
c=trulp（） 元组转换
c=str（） 字符串转换
len（） 计算字节长度
max（） 返回最大值
min（） 返回最小值

函数

drf mytest（）：
print（”hell my world“）

带参数 不带参数 传值/传址

help（函数名） 类似于linux的xxx help查看函数的详细信息
函数文档 函数名.–doc-- 对函数进行的解释，方便别人理解使用

关键字参数 def myname（xing，ming）:
print(xing+ming) 小明
def myname(ming=“明”，xing=‘小’)
print（xing+ming）

默认参数 def mynum(x=1,y=2,z=3)
和c语言中的默认参数相似， mynum（2，2）------》mynum(2,2,3) 当我们某个参数不输入时，他会用自己的默认参数来补齐

收集参数 def text(*params) *params是一个可变长度的元组
print（”长度是：“，len(params)）
print(“第二个参数是”，param【1】)
当我们要扩展params的长度时，我们常用exp=8来扩展
如 def text(*params exp=8)

变量的作用域

1. 局部变量：在某个函数中定义，只作用于指定的某个函数，当这个函数运行结束时，这个变量就会自动的消失掉，不在生效
2. 全局变量：在整个代码中都生效

global xxx 选定xxx全局变量来进行操作
nolocal xxx 选的局部变量来操作

当我们在函数中对全局变量进行操作时，pyton会自动地生成一个和全局变量同名的局部变量

内部函数的定义和调用只能在外部函数之中进行，类比局部变量

内嵌函数和闭包：def funx（x）
def funy（y）
return x*y
return funy（y）
1：funx（8）返回一个function 2：funy（5）=40

闭包

funy就是一个闭包，即内部函数对外部函数中的变量进行调用

匿名函数

匿名函数：lambda xxxxxx 创建一匿名函数
def ds(x):
return 2*x+1
ds（5）------》11

g=lambda x：2*x+1 x为传入参数

相对于传统的函数而言，匿名函数省略了函数的定义

部分函数

1. filter（） filter（function/none，可迭代数据）
   none时 返回后者迭代数据中值为true的数据
   function时 将后者的得地数据带入前者进行计算，在返回结果为真的数据
2. map（） map（function，可迭代数据）
   将后者的迭代数据带入到前者中进行计算，再将他的结果组成一个新的列表

递归

自己调用自己

案列:求阶乘

def jiecheng（x）:
if x==1:
return 1
else :
return jiecheng(x)*jiecheng(x-1)

#从functools中调用reduce()函数
from functools import reduce

#使用lambda，匿名函数，迭代
num = reduce(lambda x,y:x*y,range(1,7))
print(num)

a = int(input(‘please inputer a integer:’))
num = 1
if a < 0:
print(‘负数没有阶乘！’)
elif a == 0:
print(‘0的阶乘为1！’)
else :
for i in range(1,a + 1):
num *= i
print(num)

斐波那契数列

递归方法
def fb（x）：
if x1||x2:
return 1
else:
return fb(x-2)+fb(x-1)

普通的方法

def fb（x）：
if x1||x2
return 1
else：
n1=1
n2=2
n3=1 (随机赋予的）
if n>2：
n3=n1+n2
n1=n2
n2=n3
n=n-1
return n3
可以想象成n1 n2一次往后面移动一个位置

汉诺塔

def hanno（n，x，y,z）:
if n==1:
print(“x–>z”)
else ：
hanno(n-1,x,z,y) 将n-1个从x----》z
print（x—>z）
hanno(n-1,y,x,z) 将y上的n-1个转移到z上去

索引，字典

des={a：‘hao’,b：‘de’,c：‘ne’}
key----->value 映射关系
des【key】 的方式来访问
des【key】="hello“ 以此方式来新增字典的内容，默认新增到最后面

用元组的方法来新建字典：des1={（（‘f’，10），（‘u’，20），（‘c’，30），（‘k’，40））}
={ ‘f’:10 , ‘u’:20, ‘c’:30 , ‘k’:40}
des2={f=10,u=20,c=30,k=40}
修改方法 des2【f】=1 访问方法des2[u]---->20 新增方法 des2【too】=50

常见的字典函数：字典.keys() 返回字典的键值
for i in 字典.keys()：
print(i)
字典.values() 返回字典value
for i in 字典.values()：
print(i)
字典.items() 返回字典的key+value
for i in 字典.items()：
print(i)

字典.get(key) 访问指定key的value
字典,clear() / 字典={} 清楚数据
字典.copy 和赋值在id上有所差异
a.pop(key) 弹出指定键位上的数据
a.popitem() 随机弹出
a.update(b) 用b字典的数据来更新a字典

集合

num={1，2，3，4，5，6，7，8}

集合有唯一性，因此可以用于去重

集合的函数和前面的列表，字典都大致相似，如add。remove，等

frozen 不可变集合 num1=frozen set{1，2，3，4}
这样定义之后，该集合的数据就无法再次被做任何的修改

文件

open（文件的绝对或者是相对路径，打开方式，打开的编码方式） 一般情况下只需要指定前两者就好

f=open（’C:\desktop\1.txt‘,rw） 创建一个文件流f 以可读可写的方式打开指定的1.txt文件

r读 w写 a追加 b进制 t文本

1、r或rt 默认模式，文本模式读
2、rb 二进制文件
3、w或wt 文本模式写，打开前文件存储被清空
4、wb 二进制写，文件存储同样被清空
5、a 追加模式，只能写在文件末尾
6、a+ 可读写模式，写只能写在文件末尾
7、w+ 可读写，与a+的区别是要清空文件内容
8、r+ 可读写，与a+的区别是可以写到文件任何位

read():读取字节到字符串中

readline():打开文件的一行，包括行结束符

readline():打开文件，读取所有行

write():将字符串写入文件，写入对象为字符串

writelines():将列表写入文件，对象是列表。

seek():偏移量

tell():返回当前文件指针的位置

#1.准备文件
f = open(‘write_demo.txt’, ‘w+’) #新建文件,w+表示用于读写
f.write('你好abc王晓明，hello ') #写入内容
f.close() #文件关闭

#1.读取文件开始
f=open(“write_demo.txt”,‘r’)
content=f.read(3) #3表示读取3个字符，虽然说是byte。但是有中文时实际按字符返回的
print(“读取的内容：%s”%content)
content1=f.read(1) #注意如果用read（），读取全部，后面再加read(num),就没有内容可读了。返回空字符串
print(“读取文件的内容：%s”%content1)
content2=f.read(5)
print(“读取文件的内容：%s”%content2)
f.close()
‘’’
读取的内容：你好a
读取文件的内容：b
读取文件的内容：c王晓明，
‘’’

ps：千万注意再打开文件的时候，r，w的应用

文件系统

1. os模块
   os.name——name顾名思义就是’名字’，这里的名字是指操作系统的名字，主要作用是判断目前正在使用的平台，并给出操作系统的名字，如Windows 返回 ‘nt’; Linux 返回’posix’。注意该命令不带括号。

   			os.getcwd()——全称应该是'get current work directory'，获取当前工作的目录，如：返回结果为：'C:\\Program Files\\Python36'。注意该命令带括号，除了第一个命令不带括号之外，以下命令基本都带括号。
   			
   			os.listdir(path)——列出path目录下所有的文件和目录名。Path参数可以省略。例：  以列表的形式全部列举出来，其中没有区分目录和文件。
   			
   			os.remove(path)——删除path指定的文件，该参数不能省略。
   			os.rmdir(path)——删除path指定的目录，该参数不能省略。
   			os.mkdir(path)——创建path指定的目录，该参数不能省略。注意：这样只能建立一层，要想递归建立可用：os.makedirs()
   		     os.path.isfile(path)——判断指定对象是否为文件。是返回True,否则False
   		     os.path.isdir(path)——判断指定对象是否为目录。是True,否则False。例
                os.path.exists(path)——检验指定的对象是否存在。是True,否则False.例：
                 os.path.split(path)——返回路径的目录和文件名，即将目录和文件名分开，而不是一个整体。此处只是把前后两部分分开而已。就是找最后一个'/'。
   		     os.system(cmd)——执行shell命令。返回值是脚本的退出状态码，0代表成功，1代表不成功，例：
   	    	os.chdir(path)——'change dir'改变目录到指定目录
   			os.path.getsize()——获得文件的大小，如果为目录，返回0
   			os.path.abspath()——获得绝对路径。
   		os.path.join(path, name)—连接目录和文件名，与os.path.split(path)相对。
   			.os.path.basename(path)——返回文件名
   			 os.path.dirname(path)——返回文件路径
   

2. pickle模块
   dumps功能
   import pickle
   data = [‘aa’, ‘bb’, ‘cc’]
   dumps 将数据通过特殊的形式转换为只有python语言认识的字符串
   p_str = pickle.dumps(data)
   print(p_str)
   b’\x80\x03]q\x00(X\x02\x00\x00\x00aaq\x01X\x02\x00\x00\x00bbq\x02X\x02\x00\x00\x00ccq\x03e.
   复制代码

复制代码
loads功能
loads 将pickle数据转换为python的数据结构
mes = pickle.loads(p_str)
print(mes)
[‘aa’, ‘bb’, ‘cc’]

dump功能
dump 将数据通过特殊的形式转换为只有python语言认识的字符串，并写入文件
with open(‘D:/tmp.pk’, ‘w’) as f:
pickle.dump(data, f)

load功能
load 从数据文件中读取数据，并转换为python的数据结构
with open(‘D:/tmp.pk’, ‘r’) as f:
data = pickle.load(f)

异常处理

try：
{

检测范围

}

exception typeerror【错误类型】：
print（”wrong“）

finally：
xxxxxxxxx
else：
无异常时执行的语句

自上而下一次检测范围内是否存在exception后面的错误类型，如果存在，则执行其后面紧跟着的语句，并结束检测，其后面的exception不再做检测。
finally是无论如何都要执行的代码，用于收尾的代码，如f.close()

丰富的else语句

if： while： for：

else else else：

gui图形化界面

…

类和对象

万物皆类 类的实例 类名常以大写字母开始

属性+方法

https://blog.csdn.net/liangmaxmin/article/details/105870711?ops_request_misc=&request_id=&biz_id=102&utm_term=python%20%20%E7%B1%BB%E5%92%8C%E5%AF%B9%E8%B1%A1&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-3-.nonecase&spm=1018.2226.3001.4187

子类通过super来访父类的方法，属性
字类不能够访问父类的私有属性和私有方法

子类可以通过父类的公有方法来访问私有属性
多继承， class 字类名（父类1，父类2） 让子类对象同时具有多个父类的属性和方法
当父类们具有相同的属性或者是方法是，就要谨慎使用多继承

多态 不同的子类对象，调用相同的父类方法，产生不同的执行结果 ，即重写父类的方法

网络爬虫

1. python如何访问互联网 url + lib ----》rullib 协议+域名+路径
2. import urllib.request 模块
3. responce=urllib.request.urlopen("placekitten.com ")