目录
一、前言
一些文章参考
https://www.zhihu.com/question/348263788
python官网
python入门指南
二、基础知识笔记
1、python基础、函数
def basicStr():
print('I\'m ok.')
print('I\'m learning\nPython.')
print('\\\n\\') #\\就是\ \n换行
print('\\\t\\') #\t为制表符
print('''line1
... line2
... line3''')
print('''line1
line2
line3''')
print(r'''hello,\n
world''') #r''不转义
print(True or False)
print(True and False)
print(not 1 > 2)
print(10 / 3) #浮点数
print(10 // 3) #除数
print(10 % 3) #余数
print('Hello, %s' % 'world')
print('Hi, %s, you have $%d.' % ('Michael', 1000000))
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
r = 2.5
s = 3.14 * r ** 2
print(f'The radius {r} is {s:.2f}')
list1 = ['Michael', 'Jack', ['asp', 'php'], 'Bob', 'Tracy']
print(list1[0])
print(list1[-1])
tuple1 = ('Michael', 'Bob', 'Tracy', ['A', 'B']) #['A', 'B']中可变，这是list
tuple2 = ('Michael', 'Bob', 'Tracy') #初始化后，不可变的
print('one:%s index:%s' % (tuple1[0], tuple1[0][0]))
s = set([1, 1, 2, 2, 3, 3])
print(s)
a = 'abc'
print(a.replace('a', 'A'))
basicStr()
input("basicStr:")
输出结果：
I'm ok.
I'm learning
Python.
\
\
\ \
line1
... line2
... line3
line1
line2
line3
hello,\n
world
True
False
True
3.3333333333333335
3
1
Hello, world
Hi, Michael, you have $1000000.
3-01
3.14
The radius 2.5 is 19.62
Michael
Tracy
one:Michael index:M
{1, 2, 3}
Abc
一般函数等
#一般的函数
def function1():
print(abs(-20))
print(max(2, 3, 1, -5))
print(int('123'))
print(float('12.34'))
print(str(1.23))
print(bool(''))
print(bool(1))
function1()
####if、for循环
K=['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
def way2(n):
r=[]
if n >= len(K):
pass
else:
for i in range(n):
r.append(K[i])
return r
print(way2(3))
print(way2(5))
print(way2(7))
####while循环
def way1(m):
L = []
n=1
while n<= m:
L.append(n)
n=n+2
return L
print(way1(20))
input("way1:")
输出结果
20
3
123
12.34
1.23
False
True
['Michael', 'Sarah', 'Tracy']
[]
[]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
函数示例
#nums为可变参数 如 (1,2,4)
def calc(*nums):
sum=0
for n in nums:
sum=sum+n*n
return sum
print(calc(5,3))
print(calc(5,3,3))
def my_abs(x, y):
if x >= 0:
return x
else:
return y
print('result:%s, %d' % (my_abs(-6,0),my_abs(-6,0)))
import math
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
x,y = move(100,100,60,math.pi/6)
print(x,y)
print(x)
print(y)
r = move(100,100,60,math.pi/6)
print(r[0],r[1])
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
print(power(5,3))
def way4():
L = ['Bart', 'Lisa', 'Adam']
le = int(len(L))
i=0
while i < le:
i = i + 1
if i % 2 == 0:
continue
print('Hello, %s!' % L[i-1])
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
print(f1(1, 2, 3, 'a', 'b'))
print(f1(1, 2, 3, 'a', 'b', j=99))
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
print(f1(*args, **kw))
输出结果
34
43
result:0, 0
151.96152422706632 70.0
151.96152422706632
70.0
151.96152422706632 70.0
125
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
None
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'j': 99}
None
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
None
2、python高级特性
##### 高级特性-----切片
L1 = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
def way1(n): #取出前n个元素
r = []
for i in range(n):
r.append(L1[i])
return r
print(way1(3))
L = list(range(20))
print(L[0:3]) #取前3个元素
print(L[:3]) #取前3个元素
print(L[1:3]) #取[1,3)的元素
print(L[-2:]) #从倒数第2开始往后取元素
print(L[-2:-1]) #从倒数第2到倒数第1
print(L[-3:]) #取后3个元素
print(L[:10:2]) #前10个数，每2个取值
print(L[::5]) #所有数，每5个取一个
print(L[:]) #所有数
K = (0, 1, 2, 3, 4, 5)
print(K[:3]) #取前3个元素
print(K[:1]) #取前1个元素
##### 高级特性-----迭代
d = {'a': 1, 'b': 2, 'c': 3}
def way5():
for key in d:
print(key)
for value in d.values():
print(value)
for k, v in d.items():
print('k:%s,v:%s' % (k,v))
##判断一个对象是可迭代对象
from collections.abc import Iterable
def way6():
print(isinstance('abc', Iterable)) # str是否可迭代 True
print(isinstance([1,2,3], Iterable)) #True
print(isinstance(123, Iterable)) #整数不是可迭代 False
##Python内置的enumerate函数可以把一个list变成索引-元素对
def way7():
for i, value in enumerate(['A', 'B', 'C']):
print(i, value)
##另一种for循环
def way8():
for x, y in [(1, 1), (2, 4), (3, 9)]:
print(x, y)
##### 高级特性-----列表生成式
##[1x1, 2x2, 3x3, ..., nxn]
def way9(n):
print([x * x for x in range(1, n)])
print([x * x for x in range(1, 11) if x % 2 == 0])
print([m + n for m in 'ABC' for n in 'XYZ'])
d = {'x': 'A', 'y': 'B', 'z': 'C'}
for k, v in d.items():
print(k, '=', v)
print([k + '=' + v for k, v in d.items()])
s1 = ['Hello', 'World', 'IBM', 'Apple']
print([s.lower() for s in s1])
#取出元素后，在进行奇数、偶数不同处理
print([x if x % 2 == 0 else -x for x in range(1, 11)])
print(isinstance('abc', str))
##### 高级特性-----生成器
#斐波拉契数列【generator函数】
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
##遇到yield就中断，返回值，下次又继续执行
g = fib(6) #相当于每次的结果存储在g中
def fibTest(t):
while True:
try:
x = next(t)
print('fib t:', x)
except StopIteration as e:
print('Generator return value:', e.value)
break
print('fib g:', g)
fibTest(fib(6))
#杨辉三角
def triangles(n):
triangle = [[1], [1, 1]]
for i in range(2, n):
pre = triangle[i - 1] # 上一行
cul = [1] # 第一个元素，然后追加List
for j in range(i - 1):
cul.append(pre[j] + pre[j + 1])
cul.append(1) #最后一个元素
triangle.append(cul)
return triangle
print(triangles(8))
print(input('input:'))
输出结果是
['Michael', 'Sarah', 'Tracy']
[0, 1, 2]
[0, 1, 2]
[1, 2]
[18, 19]
[18]
[17, 18, 19]
[0, 2, 4, 6, 8]
[0, 5, 10, 15]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
(0, 1, 2)
(0,)
fib g: <generator object fib at 0x000002390284C830>
fib t: 1
fib t: 1
fib t: 2
fib t: 3
fib t: 5
fib t: 8
Generator return value: done
[[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1]]
3、python函数式编程
3.1、函数式编程-map/reduce
语法为：map(function, iterable, …)
function – 函数
iterable – 一个或多个序列
将function作用于iterable序列中的每一个元素，并将调用的结果返回
语法：reduce(function, iterable[, initializer])
用传给 reduce中的函数 function（二元函数，两个参数），先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，依次进行下去直到最后。
##### 函数式编程--高阶函数--map/reduce
def map_func(x):
res = x**2
return res
a1 = map(map_func,[1,2,3])
print('a1:', a1) ### a1: <map object at 0x0000025FB86EB588>
def map_func_2(x,y):
res = x+y
return res
a2 = map(map_func_2, [1,2,3],[1,2,3])
print('a2:', a2)
print('a2:', list(a2)) #### a2: [2, 4, 6]
print(input("in:"))
from functools import reduce
def reduce_func1(x, y):
return x+y
r1 = reduce(reduce_func1,[1,2,3]) ##将第1,2两数进行reduce_func1结果，再与第3个数据操作
print('r1:', r1)
print('r2:', reduce(lambda x, y: x+y, [1,2,3]))
###map和reduce编写一个str2float函数，把字符串转换成浮点数
## 123.456. 以.进行切片为 123 456
# 123进行转换为[1,2,3] 456转换为[4,5,6]
# 然后就是将list转换为int型组合
def str2float(s):
def fn(x, y):
return x*10+y
n = s.index('.')
s1 = list(map(int, [x for x in s[:n]]))
s2 = list(map(int, [x for x in s[n+1:]]))
return reduce(fn,s1)+(reduce(fn,s2)/10**len(s2))
3.2、函数式编程-装饰器
例子：一个decorator，对需要记录时间的函数进行监控
import time
def metric(fn):
def measure_time(*args, **kwargs):
start_time=time.time()
result=fn(*args,**kwargs)
end_time=time.time()
print('%s executed in %s ms' % (fn.__name__, end_time - start_time))
return result
return measure_time
@metric
def fast(x, y):
time.sleep(0.0012)
return x + y;
@metric
def slow(x, y, z):
time.sleep(0.1234)
return x * y * z;
f = fast(11, 22)
s = slow(11, 22, 33)
print('f:', f)
print('s:', s)
输出结果：
fast executed in 0.002238750457763672 ms
slow executed in 0.13584208488464355 ms
f: 33
s: 7986
3.2、函数式编程-偏函数
1、reduce()函数: 迭代时，当前保存的结果作为下一次循环计算的初始值。
语法：
functools.reduce (f,iterable[,initializer])
f 是fuction的缩写，是一个函数。规定这个函数必须有两个参数
iterable 是可迭代的对象，tuple, list, dictionary, string等可迭代物，必须参数
initializer 初始值，可选参数（只能给function第一个参数设置初始值，不能给第二个参数设置初始值）
import functools, operator
re1 = functools.reduce(operator.add,[1,2,3,4,5])
re2 = functools.reduce(operator.add,[1,2,3,4,5],7)
print("re1:", re1) #运行结果：((((1+2)+3)+4)+5) = 15
print("re1:", re2) #运行结果：(((((7+1)+2)+3)+4)+5) = 22
2、partial()函数: 把一个函数的部分参数设置为默认值的方式返回一个新的可以调用的（callable）的partial 对象
语法：
**functools.partial( func, *args, keywords)
*args *args表示任何多个无名参数,它是一个tuple（元组）
* *keywords **keywords表示关键字参数,它是一个dict（字典 ：键值对）
def function(a,b,c,d):
print(a,b,c,d)
#这是将1,2作为参数给function赋值前两个入参，后续fun1只需要关系后面两个参数即可
fun1 = functools.partial(function,1,2)
re3 = fun1(5,6) #输出结果：1 2 5 6
fun2 = functools.partial(function,c=1,d=2)
re4 = fun2(5,6) #输出结果: 5 6 1 2
fun3 = functools.partial(function,a=6,c=3)
re5 = fun3(b=5,d=6) #输出结果: 6 5 3 6
3、sorted()函数: 把一个可迭代对象进行排序，返回结果列表
语法：
sorted( iterable,*,key = None, reverse = False)
iterable 可迭代类型，例如字典、列表…
key = None 可迭代类型中某个属性，对给定元素的每一项进行排序
reverse = False 降序或升序
numbers = [1,6,4,-2,9]
print(sorted(numbers)) #按数值自然排序 [-2, 1, 4, 6, 9]
number_sorted = sorted(numbers, reverse=True) #按数值逆序排序
print(number_sorted) ##[9, 6, 4, 1, -2]
number_sorted2 = sorted(numbers, key=abs) #按绝对值排序
print(number_sorted2) ##[1, -2, 4, 6, 9]
number_sorted3 = sorted(numbers, key=abs, reverse=True) #按绝对值排序
print(number_sorted3) ##[9, 6, 4, -2, 1]
str1 = ["Dog","Cat","Rabbit"] #首字母均是大写
str2 = ["Dog","cat","Rabbit"] #cat首字母是小写
str3 = ["Dog","cat","Rabbit"] #cat首字母是小写
##对字符串进行排序
str1_sorted = sorted(str1) #按26字母表顺序排序
str2_sorted = sorted(str2) #按照Unicode数值来排序
str3_sorted = sorted(str3, key=str.lower) #按26字母表顺序排序
print(str1_sorted) ##['Cat','Dog','Rabbit']
print(str2_sorted) ##['Dog','Rabbit','cat']
print(str3_sorted) ##['Cat','Dog','Rabbit']
##按字符串长度排序
str_1_sorted = sorted(str_1,key = len) #按字符串长度排序
print(str_1_sorted) ###['Dog','cat','Rabbit']
##按元组的元素排序
tuple1 = [('Bob',75),('Adam',92),('Lisa',88)]
tuple2 = [('Bob',75),('Adam',92),('Lisa',88)]
tuple1_sorted = sorted(tuple1) #默认按第一个元素排序
tuple2_sorted = sorted(tuple2,key = lambda t:t[1]) #按元组的第二个元素排序
print(tuple1_sorted) ##[('Adam',92),('Bob',75),('Lisa',88)]
print(tuple2_sorted) ##[('Bob',75),('Lisa',88),('Adam',92)]
4、python面向对象编程
class Student:
def __init__(self,name,score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name,self.score))
##
bart = Student('ww',30)
bart.print_score()
print(bart.score) ##30
print(input("stop:"))
在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
class Student:
def __init__(self,name,score):
self.name = name
self.__score = score
def print_score(self):
print('%s: %s' % (self.name,self.__score)) ##内部可以调用，但外部不可调用
bart = Student('ww',30)
bart.print_score()
print(bart.name)
print(bart.__score) ##会报错
基本写法
class Student(object):
def __init__(self, name, gender):
self.name = name
self.__gender = gender
def get_gender(self):
return self.__gender
def set_gender(self,gender):
self.__gender = gender
type()函数： 返回对应的Class类型。
isinstance()函数： 一个对象是否是某种类型。
dir()函数： 获得一个对象的所有属性和方法，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法
如：
class Animal(object):
def run(self):
print('Animal is running...')
###### 继承和多态
class Dog(Animal):
def run(self):
print('Dog is running...')
def eat(self):
print('Eating meat...')
print(dir(Dog))
#得到结果是：
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'eat', 'run']
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
