python小甲鱼视频基础部分笔记(不包括类部分)

#2018/9/7 13:00

1. Python使用#注释
2. BIF= =Built in function内置函数,比如print就是一个BIF, 在shell中键入 dir(__builtins__)可以查看所有的BIF,键入help(input)可以查看input的帮助介绍,记得后面不用加括号
3. Python需要通过对齐来进行if-else的匹配,并且if和else后面都必须有冒号
4. 变量不需要声明,但是需要对其先进行赋值,命名方法与c语言是一样的…变量是区分大小写的
5. 字符串可以用单引号也可以用双引号,在字符串中需要单引号时,可以写成:
   ‘Let\’s go!’或者”Let’s go!”,\称为转义字符,对字符串中的引号进行转义,大概意思就是保留\后面的符号本来的样子,别让’这个右单引号成为字符串的结束标志,同理\n表示表示对\n进行转义

使用原始字符串print更简单,字符串前面加个r即可:
Str=r’C:\now’
跨越多行的字符串print使用三重字符串:

“““阿凡达
是否受到广
泛的的施工”””

6.类型转换 b= str(a),c=int(a),d=float(a)分别表示转化为字符串类型,整型,浮点类型
type(5.2),type(True)这样来获取变量类型
isinstance(a,int), isinstance(a,bool), isinstance(a,str), isinstance(a,float)返回bool变量,表示类型是否匹配
7 优先级问题:

8 列表:打了激素的数组

mix=[“I love fishc.com”,12,[1,2,3],23’0]

添加元素:

mix.append(“黑夜”)  在列表后面添加 
mix.extend([1,2,4])  在列表添加另一个列表在后面
mix.insert(0,"I love fishC.com") 必须两个参数,前者指定位置(注意是从0位置开始),后者指定内容

获取元素:
使用下标index获取元素:

mix[0]
'I love fishC.com'
mix[3]
[1, 2, 3, 5]
temp=mix[0]
mix[0]=mix[3]
mix[3]=temp

删除元素:

mix.remove('str') #一个参数,删除一个指定的某个值的元素,如果有多个相同的值,则一次操作只会删除一个
mix.pop() #删除最后一个元素,并返回该值
mix.pop(0)#删除第0个元素,并返回该值
del mix #删除整个mix
del mix[1]#删除mix的第一个元素

9 列表分片(slice):一次性获取多个元素,组成子列表

Mix[1:3]  #获取第一个,第二个元素,并返回其组成的一个子列表
Mix[1:1]  #返回一个空列表
Mix[:3]   #返回第0,1,2个元素
Mix[2:]   #返回第2,3,~后面所有的元素
mix[:]    #获得一个原列表的拷贝

10 列表常用操作符:

list=[123,345]   #跟C++中string比较类似
list1=[123,233]
list&list1
True
list+list1#加号两端类型要一致,所以不能通过加号来增加列表的元素
[123, 345, 123, 233]

list*3
[123, 345, 123, 345, 123, 345]
list*=2
list
[123, 345, 123, 345]
123 in list
True
123 not in list
False
list2=[123,345,["小甲鱼"]]
"小甲鱼" in list2      #次一级的列表这样无法找到
False
'小甲鱼' in list2[2]
True

list3=[233,[123,"小甲鱼","黑夜"],"牡丹"]
list3[1][2]
'黑夜'
list3.count(123)  #计算123出现的次数
0
list3.index("牡丹")  #返回下标
2
list4=[1,2,3,4,3,2,1]
list4.index(3,3,5)  #从第3个位置,到第5个位置之前(不包括5位置),查找值为3的元素的坐标index
4

list3=[233,[123,"小甲鱼","黑夜"],"牡丹"]
list3.reverse()
list3
['牡丹', [123, '小甲鱼', '黑夜'], 233]

list5=[4,64,32,5,2,54,6,4,5]
list5.sort()   #默认从小到大排序,可带参数
list5
[2, 4, 4, 5, 5, 6, 32, 54, 64]
list5.sort(reverse=True)   #反转了一下的排序
list5
[64, 54, 32, 6, 5, 5, 4, 4, 2]

list6=list5[:]   #表示拷贝
list7=list5      #不拷贝,list7和list5内容同时修改,实际上是同一个

10…元组:戴上了枷锁的列表:
由于和列表是近亲关系,所以元组和列表在使用上是十分相似的…
元组不能随意插入,删除,修改元素,元组不可改变,使用括号创建

tuple1=(1,2,3,4,3,65,0)
tuple1
(1, 2, 3, 4, 3, 65, 0)
tuple1[1]
2
tuple1[5:]  #一样的切片操作
(65, 0)
tuple1[:3]
(1, 2, 3)
>>> tuple2=tuple1[:]  #拷贝

元组的最主要标志是逗号,而不是括号
因此temp=(1)创建的变量temp不是元组类型,可以type(temp)查看其类型为int
Temp=(1,)创建的才是元组,
Temp=1,2,4,5 创建的也是元组,特别的 temp=()创建一个空元组,temp=[]创建一个空列表
因此:

8*(8)
64
8*(8,) #这里*不是乘号,而是重复操作符
(8, 8, 8, 8, 8, 8, 8, 8)

既然元组不可直接改变,那如何更新修改元组?如下,要插入一个元素,采用切片的间接方式:
可以看到temp先是指向一个元组,采用切片复制两个子元组,然后拼接新元组,然后让temp重新指向这个新元组…那么原来的元组还是依然存在,只是已经没有标签指向它了,过段时间操作系统就会回收它…删除元素的方式,也是用切片进行类似的操作

temp=('小甲鱼','黑夜','迷途','小布丁')
temp=temp[:2]+('怡静',)+temp[2:]   #('怡静',)括号和逗号都是必不可少的,否则报错
temp
('小甲鱼', '黑夜', '怡静', '迷途', '小布丁')

总结下:
可以使用在元组上的操作符:
+连接操作符,*重复操作符,查找的in,not in,下标操作符
逻辑操作符and等,关系操作符<>==等

#2018/9/8 10:00

11 字符串也是定下来就不能修改, 和元组类型在使用上很相似:

str1="I love fishc.com"
str1[1]
' '
str1[5]
'e'
str1[:6]+'插入的字符'+str1[6:]
'I love插入的字符 fishc.com'
str1
'I love fishc.com'
str1=str1[:6]+'插入的字符'+str1[6:]
str1
'I love插入的字符 fishc.com'

不过字符串常用操作更多:

字符串的格式化:

A)format格式化方法:
位置参数:

 "{0} love {1} {2}".format("I","love","FishC")
'I love love FishC'
"{a} love {b} {c}".format("I","love","FishC")
Traceback (most recent call last):   #关键字参数不能直接对应,应该有等号
  File "<pyshell#12>", line 1, in <module>
    "{a} love {b} {c}".format("I","love","FishC")
KeyError: 'a'

关键字参数:

"{a} love {b} {c}".format(a="I",b="love",c="FishC")
'I love love FishC'

混合使用位置参数和关键字参数(注意,混合使用时,位置参数必须在前面):

 "{0}love{1}{c}".format("I","love",c="FishC")
'IloveloveFishC'
"{0} love {1} {c}".format("I","love",c="FishC")
'I love love FishC'

错误(位置参数必须在前面,0不能作为关键字参数):

 "{a}love{b}{0}".format(a="I",b="love",0="FishC")
SyntaxError: keyword can't be an expression

 "{{0}}".format("不打印")
'{0}'   #因为没有位置参数,无法打印

>>> '{0:.1f}{1}'.format(27.658,'GB')
'27.7GB'

B)字符串格式化符号%方式:

例子:

'%c %c    %c'%(97,98,99)
'a b    c'
 '%d'%99.99
'99'
 "%s   "%'I love FishC.com'
'I love FishC.com   '

"%d+%d=%d"% (4.1,5.00,9)
'4+5=9'
 

"%5.1f"%2.7688
'  2.8'
"%0.1f"%2.7688
'2.8'
 "%10d"%2.768
'         2'
 "%-10d"%2.768  #左对齐
'2         '
'%#X'%108
'0X6C'
 "%010d"%2.768  #使用0替代空格
'0000000002'
"%-010d"%2.768  #使用0替代空格,只能是前面的空格
'2         '

序列的其他操作,比如min(),max()等,查看相应的文档吧

#2018/9/9 15:00
12:函数,python的乐高积木(函数,对象,模块)
例子

def MyFirstFun():
	  print('this is my first function')

	
MyFirstFun()
this is my first function

函数文档(通过.__doc__查看,或者help查看):

def MyFirstFunction(name):
	'函数定义时的name叫做形参'
	#因为ta只是一个形式,表示占据一个参数位置
	print('传递进来的name'+'%s'%name+'叫做实参,因为它是具体的参数值)')
MyFirstFunction.__doc__
'函数定义时的name叫做形参'
help(MyFirstFunction)
Help on function MyFirstFunction in module __main__:

MyFirstFunction(name)
    函数定义时的name叫做形参

形参中使用关键字参数:

def saysth(name,words):
	  print(name+"->"+words)

	
saysth('小甲鱼','改变世界')
小甲鱼->改变世界
saysth('改变世界','小甲鱼')
改变世界->小甲鱼
saysth(words='改变世界',name='小甲鱼')
小甲鱼->改变世界

默认参数:

def saysth(name='小甲鱼',words='改变世界'):
	      print(name+"->"+words)
saysth()
小甲鱼->改变世界
saysth('我')
我->改变世界
def saysth(name,words='改变世界'):
	print(name+"->"+words)
	
saysth('我')

定义默认参数时,默认参数必须靠右边,否则出错:

def saysth(name='小甲鱼',words):
	print(name+"->"+words)
	
SyntaxError: non-default argument follows default argument

收集参数(有点像C语言的指针):
即:把所有参数收集起来,构成一个元组

def test(*params):
	print('收集参数的长度是',len(params),234)
	print('第二个参数是:',params[1],34545)

	
 test('were','小甲鱼','你好',3.14,5,78)
收集参数的长度是 6 234
第二个参数是: 小甲鱼 34545

注意,如果收集参数后面,还定义了普通形参,那么在函数调用的时候,则必须使用关键字参数显示指定该普通的参数,不然调用时系统会认为所有的都是收集参数:

def test(*params,exp):
	 print('收集参数的长度是',len(params),exp)
	 print('第二个参数是:',params[1])

	
test('were','小甲鱼','你好',3.14,5,78)
Traceback (most recent call last):
  File "<pyshell#62>", line 1, in <module>
    test('were','小甲鱼','你好',3.14,5,78)
TypeError: test() missing 1 required keyword-only argument: 'exp'

test('were','小甲鱼','你好',3.14,5,78,exp=123)
收集参数的长度是 6 123
第二个参数是: 小甲鱼

所以为了避免上面这个错误,一般使用默认参数:

def test(*params,exp=123):
	print('收集参数的长度是',len(params),exp)
	print('第二个参数是:',params[1])

	
test('were','小甲鱼','你好',3.14,5,78)
收集参数的长度是 6 123
第二个参数是: 小甲鱼

函数与过程:
函数:有返回值
过程:简单的,特殊的,没有返回值的
Python严格来说,只有函数没有过程

SyntaxError: invalid syntax
def hello():
	print("hello FishC")

	
temp=hello()
hello FishC
temp
print(temp)
None
type(temp)
<class 'nonetype'="">

可以看到,函数是始终有返回值的,至少是NoneType类型的

Python函数甚至可以返回多个值(通过列表打包):

def back():
	return[1,'小甲鱼',3.14]
 back()
[1, '小甲鱼', 3.14]
>>> def back():
	return 1,'小甲鱼',3.14

back()
(1, '小甲鱼', 3.14)
def back():
	return (1,'小甲鱼',3.14)

back()
(1, '小甲鱼', 3.14)

函数变量的作用域问题,也就是全局变量,局部变量的问题
跟C++语言里面是一样的

old_val=10
def fun():
	     print(old_val)

 fun()
10

在函数内部可以访问全局变量,但是不要试图去修改全局变量,比如:

old_val=10
def fun():
	old_val=5
	print('old_value=',old_val)

fun()
old_value= 5
print('old_value',old_val)
old_value= 10

可以看到,会函数会创建一个同名的局部变量,导致不能修改全局变量
如果实在是要修改,则可以使用global关键字:

count=10
def Myfun():
	     global count
	     count=5
	     print(count)

	
Myfun()
5
count
5

内嵌函数与闭包:

Python函数嵌套:

def fun1():
	print('正在调用fun1')
	def fun2():
		print('正在调用fun2()')
	fun2()

	
 fun1()
正在调用fun1
正在调用fun2()

闭包(一种编程范式),下面的FunY就是个闭包:

def FunX(x):
	def FunY(y):
		return x*y
	return FunY

 i=FunX(8)
 i
<function funx.<locals="">.FunY at 0x0000021160AC2598&gt;
type(i)
<class 'function'="">
 i(5)
40
FunX(8)(5)
40
FunY(5)
Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    FunY(5)
NameError: name 'FunY' is not defined

变量的屏蔽问题:
与全局变量和局部变量的问题类似:

def fun1():
	 x=5
	 def fun2():
		x*=x
		return x
	 return fun2()

fun1()
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    fun1()
  File "<pyshell#44>", line 6, in fun1
    return fun2()
  File "<pyshell#44>", line 4, in fun2
    x*=x
UnboundLocalError: local variable 'x' referenced before assignment

一种解决办法是使用容器类型可以解决这个问题,因为容器是什么东西都可以往里扔,因此在全局作用域与局部作用域均可见,故可以将变量放在列表中,用[]括起来,可以进行如下改进:

def fun1():
	x=[5]
	def fun2():
		x[0]*=x[0]
		return x[0]
	return fun2()

fun1()
25

更好的方法是使用nonlocal关键字:

def fun1():
	x=5
	def fun2():
		nonlocal x
		x*=x
		return x
	return fun2()

fun1()
25

#2018/9/10 10:00

Lamada表达式(相当于一个简化版的函数定义,并且没有命名):

例如:

lambda x:2*x+1
<function <lambda=""> at 0x0000021160AC27B8&gt;
f=lambda x:2*x+1
f(2)
5
g=lambda x,y:x+y+1
g(1,2)
4
(lambda x,y:x*y+1)(2,3)
7

两个牛逼的BIF:
filter()函数:过滤器

filter(None,[1,0,False,True])
<filter object="" at="" 0x0000021160a3ef28="">
list(filter(None,[1,0,False,True]))
[1, True]

自己定义过滤的方法:

def odd(x):
	  return x%2
temp=range(10)
show=filter(odd,temp)
list(show)
[1, 3, 5, 7, 9]

使用lambda表达式:

list(filter(lambda x:x%2,range(10)))
	       
[1, 3, 5, 7, 9]

map()函数(表示映射):

list(map(lambda x:2*x,range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

递归是什么?

求阶乘的函数的普通版本:

def fun(n):
	result=n
	for i in range(1,n):
		result*=i
	return result

fun(5)
120

递归版本:

def fun2(n):
	      If  n==1:
	         return 1
	      else:
	         return n*fun2(n-1)
print(fun2(5))
120

斐波那契数列的python实现:

迭代实现:

def fab(n):
	n1=1
	n2=1
	n3=1
	if n<1:
		print("有误")
return -1
	while(n>2):
		n3=n2+n1
		n1=n2
		n2=n3
		n-=1
	return n3

 fab(12)
144

递归实现:

def fab2(n):
	   if n<1:
		    return -1
	   if n==1 or n==2:
		    return 1
	   else:
		    return fab2(n-1)+fab2(n-2)

fab2(12)
144

递归主要是编程时很巧妙,但是缺点也很明显…由于存在函数的不断调用,存在入栈出栈,断点保护,现场恢复等额外开销,实际上运行效率比迭代方式是慢很多的.比如这里,带入n=35后,就可以明显发现两种方式的速度还是有很大的差距的

汉诺塔的解法递归实现(很牛皮):

>>> def  hanoi(n,x,y,z):#n为盘子数,x,y,z为三根针,需要把所有的盘子从x->z
	       if  n==1:
		      print(x,"-->",z)
	   else:
		      hanoi(n-1,x,z,y)
		      print(x,'-->',z)
		      hanoi(n-1,y,x,z)
hanoi(3,'x','y','z')
x --> z
x --> y
z --> y
x --> z
y --> x
y --> z
x --> z

文件:

###Python打开文件的模式
r 䣧以只读模式打开文件
w 以只写模式打开文件，且先把文件内容清空（truncate the file first）
a 以添加模式打开文件，写文件的时候总是写到文件末尾，用seek也无用。打开的文件也是不能读的
r+ 以读写方式打开文件，文件可读可写，可写到文件的任何位置
w+ 和r+不同的是，它会truncate the file first
a+ 和r+不同的是，它只能写到文件末尾

模块:可用代码段的打包

pikle模块(泡菜模块):异常处理