python 个人学习笔记1

a=input('please input')
print(a)
print(r' ')
#空值none 静态、动态赋值语言
#精确除/，地板除//（即取整） ，% 求余




GB2312编码，shift_JIS编码日文
Unicode编码，ASCII编码，UTF-8编码（可变长）


ord() ,chr() ,encode() ,len()


#!/usr/bin/env python3
# -*- coding:utf-8 -*-


#!/usr/bin/env python3
#!/usr/bin/env python3
#-*- coding:utf-8 -*-
#-*- coding:utf-8 -*-



#list[]，集合
classmates=['Michael','Bob','Tracy']
len(classmates)
classmates[0]
classmates[1]
classmates[-1]#取最后一个元素
classmates[-2]#取倒数第二个元素
classmates.append('Adam')
classmates.inset(1,'Jack')
classmates.pop()#删除末尾元素
classmates.pop(1)#删除指定位置元素
classmates[1]='Sarah'#赋值提换
L=['apple',10,True]
S=['orange',['cherry','suger'],'comb']
T=[]#空list，长度0


#tuple元组,一旦初始化就不可修改，所以也没有append(),insert(),
#但是若tuple的元素里有list，然后给list里的元素重新赋值则可变
#这时变的不是tuple而是list
r=(1,2)
r=()
r=(1,)#定义只有一个元素的tuple


#int()函数


#条件判断语句
冒号，elif,记住判断从上至下


#循环语句
sun=0
for x in range(101)  #range()
sun=sun+x
print(sun)


list(range(101))


#while循环


#dict查找 ，原理：hash算法
d={'lulu':95,'bob':89,'tina':98}
d['lulu']
d['bob']=92
'lily'in d #判断是否在dict里面，不在返回False
d.get('')
d.pop('bob')#删除某个key


#set，也是一组key的集合，但不存储value，且key不可重复
#创建需提供list作为输入集合，set和dict原理一样
s=set([1,2,3]) 不表示set有序，重复元素会自动过滤
s.add(4)
s.remove(4)
s1=([2,3,4])
可做交并等运算
s&s1
s|s1


#可变对象和不变对象
#str,None是不变对象，list，[]可变
>>> a = 'abc'
>>> b = a.replace('a', 'A') #replace()
>>> b
'Abc'
>>> a
'abc'


#函数
s=area_of_circle(2)
abs(-20)#求绝对值
max(1,2,-3,5)
hex(255) #'0xff'


>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False




>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1


#定义函数，def
def my_abs(x):
if not isinstance(x,(int,float)):  #isinstance()函数，判断数据类型
raise TypeError('bad oprand type')
if x>=0:
returen x
else:
return -x


from lulu import my_abs #交互式中导入自己写的函数


def nop(): #定义一个空函数，什么都不做
pass  


#对于自己定义的函数，如果参数类型不对，Python解释器就无法帮我们检查




#函数多值返回，返回值是tuple
import math
def move(x,y,step,angle=0):
xx=x+step*math.cos(angle)
yy=y+step*math.sin(angle)
return xx,yy
x,y=move(100,100,60,math.pi/6)
print(x,y)




def power(x,n): # 定义函数x^n
s=1
while n>0:
n=n-1
s=s*x
return s
power(4,2)  #16
power(4)    #16,而对于n>2的时候，必须明确传入两个参数
#当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。
#变化小的参数就可以作为默认参数




#位置参数
#默认参数,其对象一定要是不可变对象


#可变参数*，即传入的参数的个数是可变的，可变参数在调用时自动组装成一个tuple
def calc(*numbers):#定义可变参数和定义一个list或tuple相比，在参数前加*
sum=0
for n in numbers:
sum=sum+n*n*n
return sum
calc(1,2,3)
calc()
nums=[1,2,3]
calc(*nums)


#关键字参数**，调用时函数内部自动组装成一个dict
def person(name,age,**other):#这样保证能接收到name和age这两个参数，
                                           #但是，如果调用者愿意提供更多的参数，也能收到
print ('name:',name,'age:',age,'other:',other)


#命名关键字参数*,   ，函数定义如下
def person(name, age, *,city,job):  #如果要限定关键字参数的名字，就可以用命名关键字参数
print(name,age,city,job)             #例如只接受city和job作为关键字参数,
                                              #*后面的参数被视为命名关键字参数
person('jack',24,city='beijing',job='Engineer') #调用


#与位置参数不一样，命名关键字参数必须传入参数名，否则调用报错,比如
preson('jack ', 24, 'beijing', 'Engineer') #将报错
#可设置命名关键字默认值，从而调用时可不传入该参数
def person(name, age, *,city='beijing', job)
person('jack', 24, job='Engineer')


#5种参数可组合使用，但参数定义的顺序必须是：必选-默认-可变-命名关键字和关键字


#通过tuple和dict也可以调用函数
def f(a,b, c=0, *args, **kw)
args=(1,2,3,4)
kw={'d':99, 'x':'#'}
f(*args, **kw)
a = 1 b = 2 c = 3 args = (4)  kw = {'d': 99, 'x': '#'}


#递归函数，栈溢出，尾递归：在函数返回的时候，调用自身本身，并且，return语句不能包含表达式
def fact(n): #阶乘函数
if n==1:
return 1
return n*fact(n-1)


def fact1(n, product):#改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：
if n==1:
return product
return fact1(n-1,n*product)#仅返回递归函数本身，n - 1和n * product在函数调用前就会被计算，不影响函数调用
#遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出




##高级特性
L=[]
n=1
while(n<=99):
L.append(n)
n=n+2

#1行代码能实现的功能，决不写5行代码。请始终牢记，代码越少，开发效率越高。


#切片，可省去很多循环代码
L[:]#原样复制一个list
L[0:3]
L[:3]
L[-2:-1]
L[-2:]
L[:10:2] #前10个数中每2个取一个：0,2,4,6,8
#tuple也可以用切片操作，只是操作的结果仍是tuple
#字符串也可以做切片，只是结果仍然是字符串


#迭代iteration:用for 循环遍历
#Java中用下标迭代，Python的for循环抽象程度更高一些


d = {'a':1,'b':2,'c':3}#结果是a b c ，因为dict迭代key而不是值，且无序
for key in d:              
print(key)


for value in d.values():#迭代值
for k,v in d.items():   #迭代值和key


for ch in 'ABC':  #迭代字符串
print(ch)


#通过collections模块的iterable类型来判断一个对象是否可迭代
from collections import Iterable
isinstance('abc', Iterable) #str 可迭代，返回Ture
isinstance([1,2,3],Iterable)#list，Ture
isinstance(123,Iterable)#False整数不可迭代


#对list实现类似Java下标循环，Python内置函数enumerate可把list变成索引-元素对
for i, value in enumerate(['A', 'B', 'C']):
print(i,value)


for x, y in [(1, 1), (2, 4), (3, 9)]:
print(x, y)




#列表生成器，结果都是list
list(range(1,11))


[x*x for x in range(1,11)]


[x*x for x in range(1,11) if x%2==0] 


[x+y for x in 'abc' for y in 'xyz'] #两层循环实现全排列




import os #导入模块
[d for d in os.listdir('.')] #一行代码实现 列出当前目录下的所有文件和目录名




L= ['Hello', 'World']
[s.lower() for s in L] #字符串全变成小写，lower（），若其中有非字符类型比如整数，报错
isinstance(s, str)#判断是否字符串


d={'x':1, 'y':2, 'z':3}
for k, v in d.items():
print(k, '=' v)
#或者
[k + '=' + v for k, v in d.items()]




#生成器generator，一边循环一边计算的机制，目的：节省空间
#1：把列表生成式的[]改成()，即创建一个generator
L = [x*x for x in range(10)]
L
#=>
G= (x*x for x in range(10)) #generator


next(G)
for n in G:
print(n)


#2:yield 
def fibonacci(max):0
n, a, b=0, 0, 1
while n print(b)   #改成yield b
a, b=b, a+b   #t=(b, a+b) #t是一个tuple
n=n+1           #a=t[0]
return 'done'       #b=t[1]


fibonacci(100)