七月在线之python基础入门
python的环境搭建
python包下载链接
https://pypi.org/
下载Anaconda 的方法
搜索Anaconda 清华镜像→点击并进入清华大学开源软件镜像站→点击链接→选择合适的anaconda安装包
https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/
网页编程方式
安装完annaconda后，打开Jupyter Notebook。
python规则
编程基础
exec, eval，help，三元表达式，unpack解包，*号收集，推导式，常用功能
# exec执行声明语句, eval执行表达式
exec('feng = 7')
feng
Out[4]: 7
'feng'
Out[5]: 'feng'
eval('feng')
Out[6]: 7
# 使用帮助
help(exec)
Help on built-in function exec in module builtins:
exec(source, globals=None, locals=None, /)
Execute the given source in the context of globals and locals.
The source may be a string representing one or more Python statements
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
#文本转义
print('I\' am 007')
I' am 007
#交换赋值
a,b=b,a
#命名
# 普通命名法
teacher_name='david'
teacher_name
Out[29]: 'david'
# 直接命名法
globals()['teacher']='feng'
teacher
Out[31]: 'feng'
#unpack解包
l1=[1,2,3,4,5,'6']
a,b,c,d,e,f=l1
print(a,b,c,d,e,f)
1 2 3 4 5 6
#三元表达式
age=18
'a' if age>50 else 'b'
Out[58]: 'b'
# expression只能放在左边，因为三元只能对一个变量操作。。
a=b=c=15
a=5 if b>20 else 3
a
Out[63]: 3
# copy.copy和copy.deepcopy
import copy
a = [1, 2, 3, 4, ['a', 'b']] # 原始对象
b = a # 赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变
c = copy.copy(a) # 浅拷贝，只拷贝父对象，子对象会跟着变。
d = copy.deepcopy(a) # 深拷贝,即将被复制对象完全再复制一遍作为独立的新个体单独存在
a.append(5) # 修改对象a
a[4].append('c') # 修改对象a中的['a', 'b']数组对象
a
Out[62]: [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b
Out[63]: [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c
Out[64]: [1, 2, 3, 4, ['a', 'b', 'c']]
d
Out[65]: [1, 2, 3, 4, ['a', 'b']]
#*号收集
l1=[1,2,3,4,5,'6']
a,*b,c=l1 # a 接收1，c接收6，其余放在b中
print(a,b,c)
1 [2, 3, 4, 5] 6
c
Out[19]: '6'
type(c)
Out[22]: str
# 字典推导式：
# 用字典推导式求一个字符串,以及它的位置下标
str1=['i','love','china']
{key:value for key,value in enumerate(str1)}
Out[12]: {0: 'i', 1: 'love', 2: 'china'}
# 用字典推导式求一个字符串,以及它的位置下标.(以最后一次出现的字符求位置索引)
str1='i love china for ever!'
{item:itemno for itemno,item in enumerate(str1)}
Out[3]:
{' ': 16,
'!': 21,
'a': 11,
'c': 7,
'e': 19,
'f': 13,
'h': 8,
'i': 9,
'l': 2,
'n': 10,
'o': 14,
# 常用功能说明
help(obj) 在线帮助, obj可是任何类型
eval(str) 表示合法的python表达式，返回这个表达式
exec(str) 执行合法的python声明，返回字节码
#名字空间相关
dir(obj) 查看obj的name space中可见的name
vars(obj) 返回一个object的name space。用dictionary表示
locals() 返回一个局部name space,用dictionary表示
globals() 返回一个全局name space,用dictionary表示
#类型
type(obj) 查看一个obj的类型
isinstance(obj,cls) 查看obj是不是cls的instance
issubclass(subcls,supcls) 查看subcls是不是supcls的子类
#类型转换
chr(i) 把一个ASCII数值,变成字符
ord(i) 把一个字符或者unicode字符,变成ASCII数值
oct(x) 把整数x变成八进制表示的字符串
hex(x) 把整数x变成十六进制表示的字符串
str(obj) 得到obj的字符串描述
list(seq) 把一个sequence转换成一个list
tuple(seq) 把一个sequence转换成一个tuple
dict(),dict(list) 转换成一个dictionary
int(x) 转换成一个integer
long(x) 转换成一个long interger
float(x) 转换成一个浮点数
complex(x) 转换成复数
# 查找，替换，统计
str3='http://{}.com'
#查找与替换
str3.find('o')
str3.replace('.com','.net')
#统计
str3.count('com')
可迭代对象Iterable,迭代器iterator,生成器generator
迭代对象:
以直接作用于 for 循环的数据类型有以下几种：
一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；
一类是 generator ，包括生成器和带 yield 的generator function。
这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。
说明：
1.凡是可作用于 for 循环的对象都是 Iterable 类型；
2.凡是可作用于 next() 函数的对象都是 Iterator 类型
3.集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，
不过可以通过 iter() 函数获得一个 Iterator 对象。
# 迭代器
# 可以使用 isinstance() 判断一个对象是否是 Iterable 对象：
from collections import Iterable
a = isinstance([], Iterable)
b = isinstance({}, Iterable)
c = isinstance("abc", Iterable)
d = isinstance(100, Iterable)
e = isinstance((x for x in range(10)), Iterable)
print(a) # True
print(b) # True
print(c) # True
print(d) # False 因为是Number
print(e) # True
# 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
#可以使用 isinstance() 判断一个对象是否是 Iterator 对象：
from collections import Iterator
a = isinstance([], Iterator)
a1 = isinstance(iter([]), Iterator)
b = isinstance({}, Iterator)
c = isinstance("abc", Iterator)
d = isinstance(100, Iterator)
e = isinstance((x for x in range(10)), Iterator)
print(a) #false
print(a1) #True
print(b) #false
print(c) #false
print(d) #false
print(e) #true
# 用列表推导式（还可以是字典，集合等等）生成迭代器
l1 = [x for x in range(30) if x%3==0]
# l1通过列表推导式生成一个containner。因为它是可以被for循环的，因此这个containner又是一个iterable可迭代的，iterable不一定是一个可迭代器iterator，需要加iter。iterator都是iterable。
l2 = iter(l1)
next(l2)
Out[52]: 0
next(l2)
Out[53]: 3
next(l2)
Out[54]: 6
创建生成器generator的方式有多种，我们学习其中两个常见的方式：
方式1：
用generator expressin生成一个生成器generator，只要把一个列表生成式的 [ ] 改成 ( )
方式2：
用generator function生成一个生成器generator。
# 生成器
# 用generator expressin生成一个生成器generator
l1 = (x for x in range(30) if x % 3 == 0) # []改为（）
next(l1)
Out[5]: 0
next(l1)
Out[6]: 3
type(l1)
Out[7]: generator
# 可以for循环去拿所有的
for i in l1:
print(i)
6
9
12
15
18
21
24
27
# 用generator function（如里面的yield）生成一个生成器generator
# 例1： 生成1,1,2,3,5这样的序列
# 普通方法
def fib():
a = 0
b = 0
c = 1
while a<5:
temp = c
c = c + b
b = temp
a += 1
print(b)
fib()
# 应用yeild
def fib():
a = 0
b = 0
c = 1
while a < 5:
# temp = c
# c = b + c
# b = temp
#
# a += 1
# print(b)
yield c
b,c = c,b+c
a += 1
f = fib()
print(next(f))
print(next(f))
print(next(f))
# 结果
1
1
2
# 例2
# 这里的yeild返回值，但并不停止，return返回并停止
def g2_func(n):
for i in range(n):
yield i ** 2
g2 = g2_func(7)
next(g2)
Out[5]: 0
next(g2)
Out[6]: 1
next(g2)
Out[7]: 4
next(g2)
Out[8]: 9
闭包，装饰器
# 闭包
def func1():
print("haha")
def outer(func):
def inner():
print("*******************")
func()
return inner
# 执行文件
f = outer(func1) # 相当于inner
print(f)
f() # 相当于inner（）
# 执行结果
<function outer.<locals>.inner at 0x0000003F2BE377B8>
*******************
haha
# 装饰器
# 例1：
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
func()
return inner
@w1
def f1():
print('f1')
f = f1
f()
# 结果
f1
# 例2：
# 多个函数实现不同功能普遍做法，但费时费力，如下
def fun1():
print('this is foo1 function')
def fun2():
print('this is foo2 function')
def fun3():
print('this is foo3 function')
# 为以上三个函数添加报时功能
import datetime
# 设计一个能接收函数的函数，功能是打印时间后，然后返回接收到的函数
def outer_fun(func):
print(datetime.datetime.now())
return func
outer_fun(fun2)()
# 输出结果
2019-08-15 17:30:04.253557
this is foo2 function
# 例3：
import datetime
def outer_fun(fun):
# do something you want here
str1 = 'This is string from outer'
def inner():
print(str1)
print('from inner to execute:', fun.__name__)
print('the', fun.__name__, 'result:', fun())
print('extra:', datetime.datetime.now())
return inner
# 例4：
def outer(func):
def inner():
print('executed:', func())
return inner
@outer
def fun1():
return 'this is fun1 function--'
fun1()
print(type(fun1))
# 运行结果
executed: this is fun1 function--
<class 'function'>
# 例5：
#定义函数：完成包裹数据
def makeBold(fn):
def wrapped():
return "<b>" + fn()
return wrapped
#定义函数：完成包裹数据
def makeItalic(fn):
def wrapped():
return "<i>" + fn()
return wrapped
@makeBold
def test1():
return "hello world-1"
@makeItalic
def test2():
return "hello world-2"
@makeBold
@makeItalic
def test3():
return "hello world-3"
print(test1())
print(test2())
print(test3())
# 结果
<b>hello world-1
<i>hello world-2
<b><i>hello world-3
异常处理：try…except…、try…except…else…、try…finally…、手动抛出异常raise
# 捕获并处理异常对象，后续代码可以运行
try:
a = never_named_value
print(int(a))
except ValueError: # 发生ValueError错误执行以下代码
print("Error: 函数参数传值错误")
except NameError: # 发生NameError错误执行以下代码
print("Error: 名称空间使用出错")
else:
print('Everything is fine')
print('end line')
Error: 名称空间使用出错
end line
# 手动抛出异常
# 例1
def addfunc(a,b):
if type(a)!=type(b):
raise ValueError('类别错误') #或者 raise ValueError,'Invalid value'
return a+b
addfunc(5,'f')
# 执行结果
Traceback (most recent call last):
File "D:\software\anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 2881, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "<ipython-input-16-b82082bcbeb3>", line 5, in <module>
addfunc(5,'f')
File "<ipython-input-16-b82082bcbeb3>", line 3, in addfunc
# 例2
class design_wrong(Exception): # Exception是父类
def __init__(self, length, atleast):
self.length = length
self.atleast = atleast
def main():
try:
s = input('请输入 --> ')
if len(s) < 3:
# raise引发一个你定义的异常
raise design_wrong(len(s), 3)
except design_wrong as result:#这个变量被绑定到了错误的实例
print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'%
(result.length, result.atleast))
else:
print('没有异常发生.')
main()
# 执行结果
请输入 --> 4
ShortInputException: 输入的长度是 1,长度至少应是 3
不定长位置参数，不定长关键字参数，偏函数
# 不定长位置参数
# def myadd1(a,b,c,d,*parms): # 一个*是元祖
print(type(parms))
print('parms:',parms)
print('a,b,c,d:',a,b,c,d)
return sum(parms)
myadd1(1,2,3,4,5,6)
<class 'tuple'>
parms: (5, 6)
a,b,c,d: 1 2 3 4
Out[3]: 11
# 关键字参数
#例1：
def myadd0(args,lastnum=1000): # 默认参数一定放在后面
return args+lastnum
myadd0(7)
Out[5]: 1007
#例2
def myPrint(str, age):
print(str, age)
#使用关键字参数
myPrint(age = 18, str = "张三")
Out[6]:张三 18
# 不定长关键字参数
#例1
def myadd(**kwargs): # 2个*是字典
print(kwargs)
myadd(add='sh', tel=13333)
{'add': 'sh', 'tel': 13333}
# 例2
def person(name,age,**kw):
print('name:',name,'age:',age,'other:',kw)
person('Frank','37')
person('Frank','37',city='Shanghai')
person('Frank','37',gender='M',job='Engineer')
# 结果
name: Frank age: 37 other: {}
name: Frank age: 37 other: {'city': 'Shanghai'}
name: Frank age: 37 other: {'gender': 'M', 'job': 'Engineer'}
# 综合使用（不定长位置参数，不定长关键字参数）
def myfun1(*args,**kwargs):
print(args)
for item in kwargs:
print(item)
d1={'name':'david','add':'bj','date':'2018-8-1'}
l1=[1,2,3,4,5,6,7]
myfun1(*l1,**d1)
(1, 2, 3, 4, 5, 6, 7)
name
add
date
# 偏函数
def mysal(nums,rate=2):
return nums*rate
mysal(5)
import functools
rmb2jpn=functools.partial(mysal,rate=4)
rmb2jpn(7)
Out[16]: 28
# local（），返回一个局部name space,用dictionary表示
# 函数内部定义的参数只在内部有效
b=2
def a():
f = 15
b = 34
print(locals())
a()
{'b': 34, 'f': 15}
b
Out[17]:2
函数
匿名函数，回调函数，高阶内置函数
# 匿名函数
def a(x,y):
return x+y
a(2,3)
Out[73]: 5
# 可以写成
a = lambda x,y:x+y
a(2,3)
Out[74]: 5
# 匿名函数作为参数传递
def fun(a, b, opt):
print('a=', a)
print('b=', b)
print('result=', opt(a, b))
fun(1, 2, lambda x, y: x + y)
a= 1
b= 2
result= 3
# 回调函数
# 定义：
# 回调函数就是一个通过函数指针调用的函数。
# 如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，就说这是回调函数
# 回调函数1
# 生成一个2k形式的偶数
def double(x):
return x * 2
# 回调函数2
# 生成一个4k形式的偶数
def quadruple(x):
return x * 4
# 中间函数
# 接受一个生成偶数的函数作为参数
# 返回一个奇数
def getOddNumber(k, getEvenNumber):
return 1 + getEvenNumber(k)
# 起始函数，这里是程序的主函数
def main():
k = 1
# 当需要生成一个2k+1形式的奇数时
i = getOddNumber(k, double)
print(i)
# 当需要一个4k+1形式的奇数时
i = getOddNumber(k, quadruple)
print(i)
# 当需要一个8k+1形式的奇数时
i = getOddNumber(k, lambda x: x * 8)
print(i)
main()
# 高阶内置函数
# map
map?
Init signature: map(self, /, *args, **kwargs)
Docstring:
map(func, *iterables) --> map object
Make an iterator that computes the function using arguments from
each of the iterables. Stops when the shortest iterable is exhausted.
Type: type
# map映射，它的类型是map，用list转换成列表方式查看
l1=[1,2,3,4,5,6,7]
l2=[7,8,9,10,11,12,13]
type(map(lambda x,y:x+y,l1,l2))
Out[79]: map
list(map(lambda x,y:x+y,l1,l2))
Out[78]: [8, 10, 12, 14, 16, 18, 20]
# reduce
from functools import reduce
reduce?
Docstring:
reduce(function, sequence[, initial]) -> value
Apply a function of two arguments cumulatively to the items of a sequence,
from left to right, so as to reduce the sequence to a single value.
For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates
((((1+2)+3)+4)+5). If initial is present, it is placed before the items
of the sequence in the calculation, and serves as a default when the
sequence is empty.
# 例：
from functools import reduce
l1 = [1,2,3,4]
reduce(lambda x,y:x+y,l1)
Out[84]: 10
# filter：按照给定条件过滤
l1 = [1,2,3,4]
list(filter(lambda x:True if x<3 else False,l1))
Out[86]: [1, 2]
高阶函数
map
定义： map() 会根据提供的函数对指定序列做映射。
语法 map() 函数语法： map(function, iterable, ...)
map方法的描述：创建一个迭代器，使用每个迭代项。当最短的迭代被耗尽时停止。
参数
function -- 函数，有两个参数
iterable -- 一个或多个序列
返回值： Python 2.x 返回列表。 Python 3.x 返回迭代器。
参数function传的是一个函数名，可以是python内置的，也可以是自定义的。 参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。
这个函数的意思就是将function应用于iterable的每一个元素
#将单个字符转成对应的字面量整数
def chr2int(chr):
return {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}[chr]
list1 = ["2","1","6","5"]
res = map(chr2int, list1)
print(res)
print(list(res))
<map object at 0x0000002F5BFA2F98>
[2, 1, 6, 5]
reduce
方法的描述：
将两个参数的函数累加到序列的项中，从左到右，以便将序列减少到单个值。
例如，减少（lambda x，y:x+y，[1, 2, 3，4, 5 ]）计算
（（（1＋2）＋3）＋4＋5）。如果初始存在，则放置在项目之前。
在计算中的顺序，当默认为序列
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：
用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。
格式：
reduce(function, iterable[, initializer])
参数说明：
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数
注意：一个函数作用在序列上，这个函数必须接受两个参数，reduce把结果继续和序列的下一个元素
累计运算
返回值：返回函数计算结果
例1：计算序列之和
from functools import reduce
aa=reduce(lambda x,y:x+y,[1,2,3,4,5])
print(aa)
15
例2：获取每个词出现的次数（以空格分割）
# 获取每个词出现的次数（以空格分割）
from functools import reduce
str="an apple a banana three apple a desk"
list=str.split(' ')
def fun(x,y):
if y in x:
x[y]=x[y]+1
else:
x[y]=1
return x
result=reduce(fun,list,{}) # 第三个参数为初始值, 第一次，初始字典为空，作为fun的第一个参数
print(result)
{‘an’: 1, ‘apple’: 2, ‘a’: 2, ‘banana’: 1, ‘three’: 1, ‘desk’: 1}
例3：将字符串转成对应字面量数字
#将字符串转成对应字面量数字
from functools import reduce
def str2int(str):
def fc(x, y):
return x * 10 + y
def fs(chr):
return {"0": 0, "1": 1, "2": 2, "3": 3, "4": 4, "5": 5, "6": 6, "7": 7, "8": 8, "9": 9}[chr]
a = map(fs, list(str))
# print(list(a))
# print(type(a))
return reduce(fc, a)
a = str2int("12")
print(a)
print(type(a))
filter
"""
定义：
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
方法的描述：
返回一个迭代器，为其生成函数（项）的可迭代项是真的。如果函数为“否”，则返回真实的项。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
语法
格式：
filter(function, iterable)
参数
function --参数1为函数 判断函数。
iterable --参数2为序列 可迭代对象。
'''
原型：filter(fn, lsd)
功能：用于过滤序列
白话文：把传入的函数依次作用与序列每个元素，根据返回的是True还是False决定是否保留该元素
"""
例1
#案例：筛选指定的元素
list1 = [1,2,3,4,5,6,7,8,9]
#筛选条件
def func(num):
#偶素保留
if num%2 == 0:
return True
#奇数剔除
return False
l = filter(func, list1)
print(list(l)) # [2, 4, 6, 8]
print(list1) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
例2
data= [["姓名","年龄","爱好"],["tom", 25, "无"],["hanmeimei", 26, "金钱"]]
def func2(v):
v = str(v)
if v == "无":
return False
return True
for line in data:
m = filter(func2, line)
print(list(m))
[‘姓名’, ‘年龄’, ‘爱好’]
[‘tom’, 25]
[‘hanmeimei’, 26, ‘金钱’]
sorted
"""
定义：
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别：
sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
格式：
sorted(iterable[, cmp[, key[, reverse]]])
参数说明：
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
返回值：
返回重新排序的列表。
"""
升序，降序
# 普通排序
list1 = [4,7,2,6,3]
list2 = sorted(list1)#默认升序排序
print(list2)
# 按绝对值大小排序
list3 = [4,-7,2,6,-3]
#key接受函数来实现自定义排序规则
list4 = sorted(list3, key=abs)
print(list4)
# 降序
list5 = [4,7,2,6,3]
list6 = sorted(list5, reverse=True)#默认升序排序
print(list6)
# 函数可以自己写
def myLen(str):
return len(str)
list7 = ['b333','a1111111','c22','d5554']
list8 = sorted(list7,key=myLen)#默认升序排序
print(list8)
选择排序
最小值放第一个
# 选择排序法：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放到序列的起始位置，直到全部排完。
x = [6, 3, 2, 7, 4, 9, 5]
xLen = len(x)
for i in range(xLen - 1):
min = i # 第一轮先假定最小值索引为0
# 遍历完成之后，min就指向了最小元素的下标
for j in range(i + 1, xLen):
if x[min] > x[j]:
min = j # 最小值的索引号
# 把将最小的元素值和坐标为i的元素值进行交换
x[i], x[min] = x[min], x[i]
print(x)
最大值放最后
# 选择排序法：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放到序列的起始位置，直到全部排完。
x = [6, 3, 2, 7, 4, 9, 5]
xLen = len(x)
# range(start, stop, step])
for i in range(xLen - 1, 0, -1):
m = 0
for j in range(1, i + 1):
if x[j] > x[m]:
m = j
x[m],x[i] = x[i],x[m]
print(x)
冒泡排序
# 冒泡法：第一趟：相邻的两数相比，大的往下沉。最后一个元素是最大的。
# 第二趟：相邻的两数相比，大的往下沉。最后一个元素不用比。
x = [6, 3, 2, 7, 4, 9, 5]
xLen = len(x)
for i in range(len(x) - 1, 0, -1):
for j in range(i):
if x[j] > x[j + 1]:
x[j + 1], x[j] = x[j], x[j + 1]
print(x)
LEGB
# LEGB
# L:先找外函数中的内函数的valuel ，
# E:如果找不到内函数的valuel就找外函数中，
# G:如果再找不到，就找global，
# B:最后找不到就到__builtins__中找valuel
# 例：
# 分别定义位于LEGB四个不同作用的，相同名字value1的变量
__builtins__.value1 = 'B value stored in __builtins__' # B
value1 = 'G value stored in Global' # G
# 而当出现嵌套函数inner时，也会新产生一个locals()，而如果inner此时还引用了在outter这个函数作用域内出现的变量时，就是闭包
def outter():
# Values store in Enclosure,称为闭包
value1 = 'E value stored in enclosure' # E
def inner():
value1 = 'L value stored in locals' # L
print(value1) # 此时的value1是inner1这个函数外层函数的变量
return inner
outter()()
面向对象：类，继承，类实例对象，类对象
下划线
类
# isinstance
isinstance(7,int)
Out[88]: True
# 类
# 例1：
'''
BMW = Car()，通过BMW来访问属性或者方法
表示给BMW这个对象添加属性，BMW.color = '黑色'，如果后面再次出现BMW.color = xxx表示对属性进行修改
BMW是一个对象，它拥有属性（数据）和方法（函数）
'''
# 定义类
class Car:
# 移动
def move(self):
print('车在奔跑...')
# 创建一个对象，并用变量BMW来保存它的引用
BMW = Car()
BMW.color = '黑色' # 添加类的属性，color和wheelNum
BMW.move()
print(BMW.color)
# 运行结果
车在奔跑...
黑色
# 例2：
# 学生类设计
# 总学生的人数，全部学生的姓名，已经毕业的学生的数量
# 考试功能，分数大于60分，pass,，计入总分，否则 fail
# 查分功能，如果考试次数
# 查所有已经毕业学员的姓名。
class Student(): # 这里的（）可有可无
# 类成员变量
student_total = 0 # 学生总人数
student_namelist = [] # 学生名字list
student_graduated_name_list = [] # 符合毕业要求的学生名字list
# 初始化函数，调用类时，自动运行初始化
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
self.totalscore = 0 # 总分数
self.times = 0 # 考试次数
Student.student_total += 1 # 人数
Student.student_namelist.append(name) # 名字集合
def exam(self, score): # def函数在类中定义叫方法method,以和类外部定义的函数区分
if score < 60:
print('sorry,better luck next time!')
else: # 如果超过60分
self.times += 1 # 考试次数加一
self.totalscore += score # 考试成绩累加
if self.times >= 2:
Student.student_graduated_name_list.append(self.name)
@classmethod # 类方法
def get_graducated_student_list(cls,): # 第一个参数一定是cls
return Student.student_graduated_name_list # 返回类成员变量
# 以下为执行文件
zhangsan = Student('zhangsan', 23, 'male') # 创建一个类对象，通过对象访问
lisi = Student('lisi', 24, 'female')
print('..........................................................')
print(zhangsan.age) # 张三年纪
print('..........................................................')
print(Student.student_namelist) # 名字集合
print(Student.student_total) # 学生人数
print('..........................................................')
one = zhangsan.exam(80) # 张三第一次成绩
two = zhangsan.exam(85) # 张三第一次成绩
print(zhangsan.times, zhangsan.totalscore) # 打印zhangsan考试次数及总分数
print('..........................................................')
print(Student.get_graducated_student_list())
# 执行结果
..........................................................
23
..........................................................
['zhangsan', 'lisi']
2
..........................................................
2 165
..........................................................
['zhangsan']
继承
# 继承
# 单继承
"""
说明：
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，
所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
总结
子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类
"""
# 定义一个父类，如下:
class Cat(object):
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--在跑" % self.name)
# 定义一个子类，继承Cat类如下:
class Bosi(Cat):
def setNewName(self, newName):
self.name = newName
def eat(self):
print("%s--在吃" % self.name)
bs = Bosi("印度猫")
print('bs的名字为:%s' % bs.name)
print('bs的颜色为:%s' % bs.color)
bs.eat()
bs.setNewName('波斯')
bs.run()
# 运行结果
bs的名字为:印度猫
bs的颜色为:白色
印度猫--在吃
波斯--在跑
# 多继承
"""
所谓多继承，即子类有多个父类，并且具有它们的特征
"""
#Python中多继承的格式如下:
# 定义一个父类
class A:
def printA(self):
print('----A----')
# 定义一个父类
class B:
def printB(self):
print('----B----')
# 定义一个子类，继承自A、B
class C(A,B):
def printC(self):
print('----C----')
obj_C = C() # 此处()一定要有，因为obj_C.printA()使用类实例对象调用的是obj_C的成员函数。如果没有的话，报错如下
# printA() missing 1 required positional argument: 'self'
print(C()) # C()为C类的一个实例化对象
print(C) # C相当于指向了C类
obj_C.printA()
obj_C.printB()
# 运行结果
<__main__.C object at 0x000000625E30C860>
<class '__main__.C'>
----A----
----B----
类实例对象与类对象访问实例变量的区别
# 类属性
class People(object): # (object)可有可无
name = 'Tom' #公有的类属性
__age = 12 #私有的类属性
p = People() # 此处()可有可无，因为class里面只有类成员变量。
print(p.name)
print(People.name)
print(p.__age) # 不能调用私有属性
print(People.__age) # 不能调用私有属性
# 实例属性
class People(object):
address = '山东' # 类成员变量/类属性
def __init__(self):
self.name = 'xiaowang' # 实例变量/实例属性
self.age = 20
p = People() # 创建一个类的示例对象
p.age =12
print(p.address) # 类的实例对象可以访问类成员变量，实例变量
print(p.name)
print(p.age)
print(People.address) # 类对象能调用类成员变量
print(People.name) # 类对象调不了实例变量
print(People.age)
描述符
#@property—把函数调用伪装成对属性的访问,数据描述符属性的优先级高于实例名称空间中的同名成员。
# 使用@property，不用再像java中使用getter,setter方法去设置和访问类变量
# 这时，也只有通过@property，才能对实例变量进行访问或设置，实现了对变量访问的控制，
class Student1():
def __init__(self,name,age): ###__init__实例初始化
self.name = name ####self:实例变量，变量的名字叫name
self.__age=age
@property #getter
def name1(self):
return self.name
@name1.setter # setter
def name1(self,newname):
self.name = newname
@property #getter
def age(self):
return 0
@age.setter # setter
def age(self,newage):
self.__age = newage
# 上面这样设置的是类变量可以被类实例随意访问，修改。
# 注意，这里的name1，如果和实例变量name重名会导致，无限递归！！！
# RecursionError: maximum recursion depth exceeded while calling a Python object
# 但如果想让@property和类实例变量同名呢？
# 将实例变量设置为私有(像age一样)就不会导致重名引发递归死机了
s1=Student1('jack',33)
s1.name1
s1.age #getter
s1.age=22 #setter
s1.age
类工厂函数
#Namedtuple,类工厂函数
from collections import namedtuple
# 定义一个namedtuple类型User（实际是User类），并包含name，sex和age属性。
User = namedtuple('User', ['name', 'sex', 'age'])
# 创建一个User类的实例user
user = User(name='kongxx', sex='male', age=21)
# 也可以通过一个list来创建一个User对象
user = User._make(['kongxx', 'male', 21])
print(user)
# User(name='user1', sex='male', age=21)
# 获取用户的属性
print(user.name)
print(user.sex)
print(user.age)
# 修改对象属性，注意要使用"_replace"方法
user = user._replace(age=22)
print(user)
# 将User对象转换成字典，注意要使用"_asdict"
print(user._asdict()) # OrderedDict([('name', 'kongxx'), ('sex', 'male'), ('age', 22)])
元类
内置函数type()除了查看对象所属类型外，还有种非凡的能力，即能抛开固化的类创建代码，而动态的创建类。
而且通过type()函数创建的类和直接写class是完全一样的。
因为解释器遇到class关键字时，扫描一下class定义的语法，最后还是调用type()函数创建出class
#type()函数依次传入3个参数：
# 1.class的名称
# 2.class继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法；
# 3.class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
# MyShinyClass = type('MyShinyClass', (), {})
# Foo = type('Foo', (), {'bar':True})
# FooChild = type('FooChild', (Foo,), {})
s1=dict(locals())
Foo = type('Foo', (), s1)
FooChild = type('FooChild', (Foo,), s1)
print(FooChild.__mro__)
文件操作：文件打开、关闭、读写、定位读写，重命名，删除
# 文件打开
f = open('test.txt', 'w')
说明: 访问模式 说明 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到
已有内容之后。如果该文件不存在，创建新文件进行写入。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，
新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。
如果该文件不存在，创建新文件用于读写。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
如果该文件不存在，创建新文件用于读写。
# 文件关闭
f = open('test.txt', 'w')
f.close()
# 文件写
#使用write()可以完成向文件写入数据
f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()
"""
注意：
如果文件不存在那么创建，如果存在那么就先清空，然后写入数据
"""
# 文件读
# 读文件三大方法：
# read() 一个一个读，全部读完
# read(n) 读取前n个
# readline() 按行读
# readlines() 全部读
# read()方法
# 写文件
f = open('test.txt', 'w') # 如果没有，就创建一个文件
f.write('hello world, \ni am here!')
f.close()
#读文件，read()函数
# 如果前面有read()或read(5)，会接着读，而不是重新读
f = open('test.txt', 'r')
content1 = f.read(5)
print(content1)
print("-"*30)
content2 = f.read()
print(content2)
f.close()
# 执行结果：
hello
------------------------------
world,
i am here!
# readlines()方法
# 写文件
f = open('test.txt', 'w') # 如果没有，就创建一个文件
f.write('hello world, \ni am here!')
f.close()
# 读文件
f = open('test.txt', 'r')
content = f.readlines()
print(content)
print(type(content))
i=1
for temp in content:
print("%d:%s"%(i, temp))
i+=1
f.close()
# 执行结果
['hello world, \n', 'i am here!']
<class 'list'>
1:hello world,
2:i am here!
# readline()方法
# 写文件
f = open('test.txt', 'w') # 如果没有，就创建一个文件
f.write('hello world, \ni am here!')
f.close()
#readline()
f = open('test.txt', 'r')
content = f.readline()
print(content)
f.close()
# 执行结果
hello world,
# 文件定位读写
"""
seek(offset, from)有2个参数
offset:偏移量
from:方向
0:表示文件开头
1:表示当前位置
2:表示文件末尾
"""
#把位置设置为：从文件开头，偏移5个字节
# 打开一个已经存在的文件
f = open("test.txt", "r")
str = f.read(5)
print ("读取的数据是 : ", str)
# 查找当前位置
position = f.tell()
print ("当前文件位置 : ", position)
# 重新设置位置
f.seek(7,0)
# 查找当前位置
position = f.tell()
print ("当前文件位置 : ", position)
f.close()
# 运行结果
读取的数据是 : hello
当前文件位置 : 5
当前文件位置 : 7
# 文件重命名
import os
os.rename("test.txt", "haha.txt")
# 文件删除
import os
os.remove("haha.txt")
文件夹操作：创建文件夹，获取当前目录，获取目录列表，删除文件夹（os模块）
# 创建文件夹
import os
os.mkdir("张三")
# 获取当前目录
import os
os.getcwd()
# 获取目录列表
import os
print(os.listdir("./"))
# 执行结果
['.idea', '1.py', '张三']
# 删除文件夹
import os
os.rmdir("张三")
PIL库
参考：https://blog.csdn.net/figo8875/article/details/88755122
生成一张固定尺寸固定颜色的图片
# 生成一张固定尺寸固定颜色的图片
from PIL import Image
# 获取一个Image对象，参数分别是: RGB模式, 宽150，高30，红色
image = Image.new('RGB', (150, 30), 'red')
# 保存到硬盘，名为test.png,格式为png的图片
# wb,以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
image.save(open('test.png', 'wb'), 'png')
生成一张随机颜色的图片
# 生成一张随机颜色的图片
from PIL import Image
import random
def getRandomColor():
# 获取一个随机颜色(r,g,b)格式的
c1 = random.randint(0, 255)
c2 = random.randint(0, 255)
c3 = random.randint(0, 255)
return (c1, c2, c3)
# 获取一个Image对象，参数分别是RGB模式。宽150，高30，随机颜色
image = Image.new('RGB', (150, 30), getRandomColor())
# 保存到硬盘，名为test.png格式为png的图片
image.save(open('test.png', 'wb'), 'png')
生成一张带有固定字符串的随机颜色的图片
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import random
def getRandomColor():
'''获取一个随机颜色(r,g,b)格式的'''
c1 = random.randint(0, 255)
c2 = random.randint(0, 255)
c3 = random.randint(0, 255)
return (c1, c2, c3)
# 获取一个Image对象，参数分别是RGB模式。宽150，高30，随机颜色
image = Image.new('RGB', (150, 30), getRandomColor())
# 获取一个画笔对象，将图片对象传过去
# 创建一个可用来对image进行操作的对象。对所有即将使用ImageDraw中操作的图片都要先进行这个对象的创建
draw = ImageDraw.Draw(image)
# 获取一个font字体对象,参数:是ttf的字体文件的目录，字体的大小
# ImageFont.truetype(filename , wordsize)
# 这个函数创建字体对象给ImageDraw中的text函数使用。
font = ImageFont.truetype('simhei.ttf', size=25)
# 在图片上写东西,参数是：定位，字符串，颜色，字体
draw.text((12, 1), '我是字符串', getRandomColor(), font=font)
# 保存到硬盘，名为test.png格式为png的图片
image.save(open('test.png', 'wb'), 'png')
生成一张带有随机字符串随机颜色的图片
# 生成一张带有随机字符串随机颜色的图片
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import random
def getRandomColor():
'''获取一个随机颜色(r,g,b)格式的'''
c1 = random.randint(0, 255)
c2 = random.randint(0, 255)
c3 = random.randint(0, 255)
return (c1, c2, c3)
def getRandomStr():
'''获取一个随机字符串，每个字符的颜色也是随机的'''
# 0~9的数字
random_num = str(random.randint(0, 9))
#利用random.randint()函数生成一个随机整数a，使得97<=a<=122
#chr,对应从a到z的ASCII码
# 小写字母
random_low_alpha = chr(random.randint(97, 122))
# 大写字母
random_upper_alpha = chr(random.randint(65, 90))
# choice(seq): 从seq序列中（可以是列表，元组，字符串）随机取一个元素返回
random_char = random.choice([random_num, random_low_alpha, random_upper_alpha])
return random_char
# 获取一个Image对象，参数分别是RGB模式。宽150，高30，随机颜色
image = Image.new('RGB', (150, 30), getRandomColor())
# 获取一个画笔对象，将图片对象传过去
draw = ImageDraw.Draw(image)
# 获取一个font字体对象参数是ttf的字体文件的目录，以及字体的大小
font = ImageFont.truetype("simhei.ttf", size=26)
for i in range(4):
# 循环4次，获取4个随机字符串
random_char = getRandomStr()
# 在图片上一次写入得到的随机字符串,参数是：定位，字符串，颜色，字体
draw.text((15 + i * 30, 0), random_char, getRandomColor(), font=font)
# 保存到硬盘，名为test.png格式为png的图片
image.save(open('test.png', 'wb'), 'png')
生成一张模糊的随机数字4位验证码图片
from PIL import Image, ImageDraw, ImageFont, ImageFilter
import random
def getCaptcha(width=40, height=30, n=4, line=0):
# 随机字母
def rndNum():
return str(random.randint(1, 9))
# 为画布随机颜色
def rndColor():
return (random.randint(100, 255), random.randint(100, 255), random.randint(100, 255))
# 为字体随机颜色
def rndColor2():
return (random.randint(30, 120), random.randint(30, 120), random.randint(30, 120))
# 创建图片对象
image = Image.new('RGB', (width, height), (255, 255, 255))
# 创建Font对象
font = ImageFont.truetype('arial.ttf', 36)
# 创建Draw对象
draw = ImageDraw.Draw(image)
# 填充每个像素
for x in range(width):
for y in range(height):
draw.point((x, y), fill=rndColor())
# 输出文字
for t in range(n):
draw.text((40 * t + 10, 10), rndNum(), font=font, fill=rndColor2())
# 模糊
image = image.filter(ImageFilter.BLUR)
image.save('verify.png', 'png')
getCaptcha(width=160, height=60, n=4, line=0)
正则表达式/Regular Expression
参考：https://blog.csdn.net/m0_37673307/article/details/81605053
正则表达式30分钟入门教程：https://deerchao.net/tutorials/regex/regex.htm
https://www.jianshu.com/p/04cb736fd375
规则
正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。
在很多文本编辑器里，正则表达式通常被用来检索、替换那些匹配某个模式的文本
在Python中需要通过正则表达式对字符串进行匹配的时候，可以使用一个模块，名字为re
re模块的使用过程：
# 导入re模块
import re
# 使用match方法进行匹配操作
result = re.match(正则表达式,要匹配的字符串)
# 如果上一步匹配到数据的话，可以使用group方法来提取数据
result.group()
说明：
re.match是用来进行正则匹配检查的方法，若字符串匹配正则表达式，则match方法返回匹配对象（Match Object），否则返回None（注意不是空字符串""）。
匹配对象Macth Object具有group方法，用来返回字符串的匹配部分。
正则表达式的字符功能：
. 匹配任意1个字符（除了\n）
[ ] 匹配[ ]中列举的字符
\d 匹配数字，即0-9
\D 匹配非数字，即不是数字
\s 匹配空白，即 空格，tab键
\S 匹配非空白
\w 匹配单词字符，即a-z、A-Z、0-9、_
\W 匹配非单词字符
举例
用[1-9]?[0-9]这个正则去匹“09787787” 先判断第一个是不是0 ，如果是0 不符合【1-9】 到那时[1-9]?可以没有 所以 0再匹配后面【0-9】 符合 ，这时正则表达式匹配完成，字符串后面的就不管了。
用[1-9]?[0-9]这个正则去匹“892888” ，第一个是非0 满足【1-9】 条件，输出第一个 8。 再判断字符串第二个是不是满足[0-9] ，9满足条件输出9 ，所以最后是 89 ，字符串其余不管。
# [1-9]?[1-9]表示匹配一个也行 两个也行
ret = re.match("[1-9]?[0-9]","09")
print(ret.group()) # 0
# [1-9][1-9] 表示必须匹配两个数字
ret = re.match("[0-9][0-9]","19332")
print(ret.group())#19
爬虫
HTML基础知识：https://www.w3cschool.cn/html/
CSS基础知识：https://www.w3cschool.cn/css/
使用requests获取网页内容
http://docs.python-requests.org/zh_CN/latest/user/quickstart.html
python刷题
输出200以内的可逆素数
# 思路：先找出素数，再找逆素数
# 素数：整数在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数
# 可逆素数是将某素数的各位数字顺序颠倒后仍为素数的数，请编程并输出200以内的可逆素数
numb = 200
for s in range(2, numb):
for j in range(2,s):
# 判断是否是素数
if s%j == 0:
break
else:
# 素数的前提下，判断是否是逆素数
conv_s = int(str(s)[::-1]) # 将素数转换成字符串后颠倒再转换int
for n in range(2, conv_s):
if conv_s % n == 0:
break
else:
print(s)
统计字符串中，各个字符的个数
# 统计字符串中，各个字符的个数
# 比如："hello world" 字符串统计的结果为： h:1 e:1 l:3 o:2 d:1 r:1 w:1
W = 'hello world'
W = W.replace(' ', '') # 去掉空格字符
dic = {}
for item in W:
# 如果item在dic的key里，则对应item键的值加1
if item in dic.keys():
dic[item] += 1
else:
dic[item] = 1
print('"hello world" 字符串统计的结果为: ')
print(dic)
模拟斗地主，有3个玩家，一付扑克牌，留3张底牌， 将扑克牌随机分配给3个玩家并显示（注意有四种花色和两个王）
例1：
import random
class Poke():
poke = [] # 扑克牌牌堆
p1 = [] # 玩家一牌堆
p2 = [] # 玩家二牌堆
p3 = [] # 玩家三牌堆
last = None # 底牌牌堆
def __init__(self, f, num): # 初始化牌堆
self.flower = f # 花色
self.num = num # 点数
def __str__(self):
return "%s%s" % (self.flower, self.num) # 返回牌值
@classmethod
def init(cls): # 定义牌堆
ph = ("♥", "♠", "♣", "♦") # 花色元组
pnum = ("2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A") # 点数元组
king = {"big": "大王", "small": "小王"} # 大小王
for p in ph: # 循环遍历花色
for _nump in pnum: # 循环遍历点数
# print(Poke(p, _nump))
cls.poke.append(Poke(p, _nump)) # 装牌
################################################
print(type(Poke.poke)) # <class 'list'>
print(Poke.poke) # 他是一个object
for i in cls.poke:
print(i, end=" ")
print()
################################################
# print(Poke(king["big"], ""))
cls.poke.append(Poke(king["big"], "")) # 装大王
cls.poke.append(Poke(king["small"], "")) # 装小王
@classmethod
def wash(cls): # 洗牌
random.shuffle(cls.poke)
print(Poke.poke)
@classmethod
def send(cls): # 发牌
for _ in range(0, 17): # 三个人每人发17张牌
cls.p1.append(cls.poke.pop(0)) # 玩家一发牌 pop(0)是删除cls.poke的第一个数并返回第一个数
cls.p2.append(cls.poke.pop(0)) # 玩家二发牌
cls.p3.append(cls.poke.pop(0)) # 玩家三发牌
cls.last = tuple(cls.poke) # 最后三张牌做底牌
@classmethod
def show(cls): # 展示牌
print("玩家1:")
for pokes in cls.p1:
print(pokes, end=" ")
print()
print("玩家2:")
for pokes in cls.p2:
print(pokes, end=" ")
print()
print("玩家3:")
for pokes in cls.p3:
print(pokes, end=" ")
print()
print("底牌：")
for pokes in cls.last:
print(pokes, end=" ")
print()
Poke.init()
Poke.wash()
Poke.send()
Poke.show()
例2
#斗地主
import random as R
"""一次一人发一张牌"""
L = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
H = ['♠', '♦', '♥', '♣']
w1 = []
w2 = []
w3 = []
P = ['大王', '小王']
for x in H:
for y in L:
s = x + y
P.append(s)
R.shuffle(P)
i = 1
while i <= 17:
w1.append(P.pop())
w2.append(P.pop())
w3.append(P.pop())
i += 1
print('玩家1号')
print(w1)
print('玩家2号')
print(w2)
print('玩家3号')
print(w3)
print('底牌')
print(P)
执行结果：
玩家1号
[‘♦J’, ‘♠7’, ‘♥7’, ‘♠2’, ‘♣4’, ‘♠8’, ‘♦8’, ‘♣K’, ‘♦9’, ‘♥10’, ‘♠4’, ‘♣8’, ‘♦5’, ‘♥4’, ‘♥2’, ‘♠5’, ‘♣J’]
玩家2号
[‘♣A’, ‘♠3’, ‘♦Q’, ‘♣5’, ‘♥3’, ‘♥9’, ‘♥5’, ‘♣9’, ‘♠K’, ‘♦K’, ‘♠9’, ‘♦4’, ‘♥8’, ‘♥J’, ‘♣6’, ‘♣2’, ‘♦7’]
玩家3号
[‘♦10’, ‘♣3’, ‘♠6’, ‘♦3’, ‘♦A’, ‘♦6’, ‘♥6’, ‘♦2’, ‘♠J’, ‘♣Q’, ‘♥Q’, ‘♣10’, ‘♥A’, ‘♥K’, ‘大王’, ‘小王’, ‘♣7’]
底牌
[‘♠10’, ‘♠A’, ‘♠Q’]
设计一个公司类
'''
设计一个公司类，完成以下要求，并实例化不同对象进行验证
类变量
- 类下公司的总个数，类下实例的名称列表
类方法
- 返回公司类共有多少个公司实例
- 返回公司类的公司实例有名称列表
实例变量
- 公司名，简介，利润，销售额，总成本，雇员姓名
实例方法：
- 招聘人才（每招一个人会有成本产生，影响该实例雇员列表，人数，总成本）
- 解雇人员（每解雇一个人会有成本产生，影响该实例雇员列表，人数 ，总成本）
- 公司广告推广(影响该实例总成本)
- 交社保(按公司雇员总人数计算，影响该实例总成本)
- 交税(按公司雇员总人数计算，影响该实例总成本)
- 销售（按销售件数*价格计算销售额，利润按销售额*利润率进行计算利润。）
- 获取公司雇员列表
- 获取公司净利润
'''
class Company():
num = 0 # 公司的总个数
name = [] # 实例的名称列表
def __init__(self, Company_name, Desc,Profit, TotalSales, TotalCost, EmployeeName):
# 实例变量: 公司名，简介，利润，销售额，总成本，雇员姓名
self.Company_name = Company_name # 公司名
self.Desc = Desc # 简介
self.Profit = Profit # 利润
self.TotalSales = TotalSales # 销售额
self.TotalCost = TotalCost # 总成本
self.EmployeeName = EmployeeName # 雇员姓名
self.Employee_number = len(self.EmployeeName) # 雇员数量
Company.num += 1
Company.name.append(Company_name)
# 招聘人才（每招一个人会有成本产生，影响该实例雇员列表，人数，总成本）
def recuitment(self, r_name, r_salary):
self.EmployeeName.append(r_name) # 雇员列表
self.TotalCost += r_salary # 总成本
self.Employee_number += 1 # 雇员人数
# 解雇人员（每解雇一个人会有成本产生，影响该实例雇员列表，人数 ，总成本）
def fire(self, f_name, f_salary):
self.EmployeeName.remove(f_name) # 雇员列表
self.TotalCost -= f_salary # 总成本
self.Employee_number -= 1 # 雇员人数
# 公司广告推广(影响该实例总成本)
def advertise(self, ad_cost):
self.TotalCost += ad_cost # 总成本
# 交社保(按公司雇员总人数计算，影响该实例总成本)
def s_security(self, s_cost):
self.TotalCost += s_cost * self.Employee_number
# 交税(按公司雇员总人数计算，影响该实例总成本)
def tax(self, t_cost):
self.TotalCost += t_cost * self.Employee_number
# 销售（销售件数*价格 = 销售额，销售额*利润率 = 利润。）
def sale(self, sale_number, profit_rate, price):
self.TotalSales += sale_number * price # 销售件数*价格 = 销售额
self.Profit += sale_number * price * profit_rate # 销售件数*价格*利润率 = 利润
# 获取公司雇员列表
def get_employee(self):
return self.EmployeeName
# 获取公司净利润
def get_profit(self):
return self.Profit
# 装饰器：类方法
@classmethod
def get_num(cls): # 返回公司类共有多少个公司实例
return cls.num
# 装饰器：类方法
@classmethod
def get_name(cls): # 返回公司类的公司实例有名称列表
return cls.name
def main():
c = Company('C','Company C',0,12,12,['Feng','Zhang']) # 公司名，简介，利润，销售额，总成本，雇员姓名
c.recuitment('Gua', 4) # 招聘人才 参数：人名，薪水
c.fire('Feng', 3) # 解雇人员 参数：人名，薪水
c.advertise(0.5) # 公司广告推广 参数：广告成本
c.s_security(0.2) # 交社保 参数：广告成本
c.tax(0.1) # 交税 参数：税成本
c.sale(10,0.3,100) # 销售 参数：销售件数，利润率，价格
print('公司名字：', c.Company_name)
print('总费用：', c.TotalCost)
print('公司员工：', c.get_employee())
# 类方法的调用
print('公司名称：', Company.get_name())
print('公司数量：', Company.num)
if __name__ == '__main__':
main()
while循环完成图形输出
'''
使用while，完成以下图形的输出
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
'''
i = 0
while i <=5:
j = 0
while j <= i:
print("*",end=" ") # end值为空格
j += 1
print("") # end值为默认值（换行\n）
i += 1
i = 4
while i >= 0:
j = 0
while j <= i:
print("*",end=" ")
j += 1
print("")
i -= 1
“名片管理器”项目
"""
编写程序，完成“名片管理器”项目
需要完成的基本功能：
添加名片
删除名片
修改名片
查询名片
退出系统
程序运行后，除非选择退出系统，否则重复执行功能
须使用自定义函数，完成对程序的模块化
学生信息至少包含：姓名、年龄、学号，除此以外可以适当添加
必须完成的功能：添加、删除、修改、查询（单个查询/显示所有）、退出
"""
'''
学生信息系统：
要求： 用键盘录入的方式
根据序列完成：
1. 添加一个新的名片")
2. 删除一个名片")
3. 修改一个名片")
4. 查询一个名片")
5. 显示所有的名片")
6. 退出系统"
'''
# 用来存储名片
card_infors = []
def print_menu():
"""完成打印功能菜单"""
print("=" * 50)
print(" 名片管理系统 V0.01")
print(" 1. 添加一个新的名片")
print(" 2. 删除一个名片")
print(" 3. 修改一个名片")
print(" 4. 查询一个名片")
print(" 5. 显示所有的名片")
print(" 6. 退出系统")
print("=" * 50)
def add_new_card_infor():
"""完成添加一个新的名片"""
new_name = input("请输入新的名字:")
new_qq = input("请输入新的QQ:")
new_weixin = input("请输入新的微信:")
new_addr = input("请输入新的住址:")
# 定义一个新的字典,用来存储一个新的名片
new_infor = {}
new_infor['name'] = new_name
new_infor['qq'] = new_qq
new_infor['weixin'] = new_weixin
new_infor['addr'] = new_addr
# 将一个字典,添加到列表中
global card_infors
card_infors.append(new_infor)
# print(card_infors) # for test
def del_card_infors():
"""用来删除一个名片"""
global card_infors
find_name = input("请输入要删除的姓名:")
find_flag = 0
for temp in card_infors:
tem = 0
if temp['name'] == find_name:
print(card_infors)
card_infors.pop(tem)
find_flag = 1 # 表示找到了
break
tem += 1
# 判断是否找到了
if find_flag == 0:
print("查无此人....")
def modif_card_infors():
"""用来修改一个名片"""
global card_infors
find_name = input("请输入要修改的姓名:")
find_flag = 0
for temp in card_infors:
tem = 0
if temp['name'] == find_name:
print(card_infors)
print("=" * 50)
print(" 请输入要修改的名片信息：")
print(" 1. QQ")
print(" 2. 微信")
print(" 3. 住址")
print(" 4. 临时不修改了")
print("=" * 50)
while True:
# 获取用户的输入
num = int(input("请输入要修改名片信息或退出对应的序号:"))
# 根据用户的数据执行相应的功能
if num == 1: # QQ
new_qq = input("请输入新的QQ:")
temp['qq'] = new_qq
elif num == 2: # 微信
new_weixin = input("请输入新的微信:")
temp['weixin'] = new_weixin
elif num == 3: # 地址
new_addr = input("请输入新的住址:")
temp['addr'] = new_addr
elif num == 4: # 退出系统
break
else:
print("输入有误,请重新输入")
print("")
find_flag = 1 # 表示找到了
break
tem += 1
# 判断是否找到了
if find_flag == 0:
print("查无此人....")
def find_card_infor():
"""用来查询一个名片"""
global card_infors
find_name = input("请输入要查找的姓名:")
find_flag = 0 # 默认表示没有找到
for temp in card_infors:
if find_name == temp["name"]:
print("%s\t%s\t%s\t%s" % (temp['name'], temp['qq'], temp['weixin'], temp['addr']))
find_flag = 1 # 表示找到了
break
# 判断是否找到了
if find_flag == 0:
print("查无此人....")
def show_all_infor():
"""显示所有的名片信息"""
global card_infors
print("姓名\tQQ\t微信\t住址")
for temp in card_infors:
print("%s\t%s\t%s\t%s" % (temp['name'], temp['qq'], temp['weixin'], temp['addr']))
def main():
"""完成对整个程序的控制"""
# 1. 打印功能提示
print_menu()
while True:
# 2. 获取用户的输入
num = int(input("请输入操作序号:"))
# 3. 根据用户的数据执行相应的功能
if num == 1:
add_new_card_infor() # 添加名片
elif num == 2:
del_card_infors() # 删除名片
elif num == 3:
modif_card_infors() # 修改名片
elif num == 4:
find_card_infor() # 查询名片
elif num == 5:
show_all_infor() # 显示所有名片
elif num == 6:
break # 退出系统
else:
print("输入有误,请重新输入")
print("")
# 调用主函数
main()
842
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
