本文解析Python中is与==的区别，通过代码实例演示，并深入讲解高阶函数如map、reduce、filter的应用，以及类的设计和数据结构操作。
python面试_总结02_代码题
1.1 简答题
请谈谈Python中is 和 == 的区别(写代码演示)¶
is用于比较两个变量是否引用了同一个内存地址 is 表示的是对象标示符（object identity），作用是用来检查对象的标示符是否一致，也就是比较两个对象在内存中的地址是否一样。
==用于比较两个变量的值是否相等,== 表示的是相等（equality），是用来检查两个对象是否相等。
is 是检查两个对象是否指向同一块内存空间，而 == 是检查他们的值是否相等。
可以看出，is 是比 == 更严格的检查，is 返回True表明这两个对象指向同一块内存，值也一定相同。
In [3]:
%config ZMQInteractiveShell.ast_node_interactivity='all'
%pprint
Pretty printing has been turned ON
In [21]:
# case 1:对于（比较小）数值型和（比较短）字符串型对象, python的存储机制使得a和b其实指向同一个地址，所以is和==都是True
a = 1
b = 1
a is b
a == b
a = 'max'
b = 'max'
a is b
a == b
# case 2:对于list、tuple等容器，a和b虽然内容一样，但是是两个不同的对象引用，指向两个不同的内存地址
list = [a,b]
tuple = (a,b)
type(list)
type(tuple)
id(list)
id(tuple)
# case 3：实际上可以通过修改对象的__eq__方法改变==的比较方式，自定义一个类，并尝试重写__eq__方法让==一定返回False
# 方法1
def __eq__(a,b):
if a == b:
print(False)
else:
print(True)
__eq__(1,1)
# 方法2
a1 = lambda a,b : not (a == b)
a1(1,1)
Out[21]:
True
Out[21]:
True
Out[21]:
True
Out[21]:
True
Out[21]:
list
Out[21]:
tuple
Out[21]:
2185052250368
Out[21]:
2185051702912
False
Out[21]:
False
In [12]:
def __eq__(a,b):
if a == b:
print(False)
else:
print(True)
__eq__(1,1)
False
In [20]:
a1 = lambda a,b : not (a == b)
a1(1,1)
Out[20]:
False
提示：我们指的是map、reduce、filter这类函数
In [3]:
# map()
# map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
# map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，
# 因此通过list()函数让它把整个序列都计算出来并返回一个list。
# =========================================================
# 以下代码仅适用于命令行操作，notebook中会报错TypeError: 'list' object is not callable 是因为 变量名 list 与函数list()重名
def f(x):
return x * x + 1
m = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(m)
list(map(str,[1,2,3,4]))
from math import factorial
def square(n):
return n ** 3
factMap = map(factorial,list(range(10)))
print(list(factMap))
# 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']
def normalize(name):
return name.capitalize()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
# =========================================================
# reduce()
# reduce()把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，
# 其效果就是：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
from functools import reduce
result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(result)
# filter()
# Python内建的filter()函数用于过滤序列
#和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
#sorted()
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880] ['Adam', 'Lisa', 'Bart'] 15
In [42]:
from functools import reduce
result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(result)
15
In [2]:
# 利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：
# -*- coding: utf-8 -*-
def normalize(name):
return name.capitalize()
L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print(L2)
['Adam', 'Lisa', 'Bart']
In [46]:
# Python提供的sum()函数可以接受一个list并求和，请编写一个prod()函数，可以接受一个list并利用reduce()求积：
# -*- coding: utf-8 -*-
from functools import reduce
def prod(L):
def product_rule(x,y):
return x*y
return reduce(product_rule,L)
print('3 * 5 * 7 * 9 =', prod([3, 5, 7, 9]))
if prod([3, 5, 7, 9]) == 945:
print('测试成功!')
else:
print('测试失败!')
3 * 5 * 7 * 9 = 945 测试成功!
Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。
In [4]:
# 在一个list中，删掉偶数，只保留奇数
# filter()
def is_odd(n):
return n%2 == 1
list(filter(is_odd,[1,2,4,5,6,9,10,15,18,21]))
Out[4]:
[1, 5, 9, 15, 21]
In [5]:
def _odd_iter():
n = 1
while True:
n = n + 2
yield n
def _not_divisible(n):
return lambda x: x % n > 0
def primes():
yield 2
it = _odd_iter() # 初始序列
while True:
n = next(it) # 返回序列的第一个数
yield n
it = filter(_not_divisible(n), it) # 构造新序列
# 打印1000以内的素数:
for n in primes():
if n < 1000:
print(n)
else:
break
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997
In [1]:
sorted([36, 5, -12, 9, -21])
Out[1]:
[-21, -12, 5, 9, 36]
In [2]:
sorted([36, 5, -12, 9, -21], key=abs)
Out[2]:
[5, 9, -12, -21, 36]
In [3]:
sorted(['bob', 'about', 'Zoo', 'Credit'])
Out[3]:
['Credit', 'Zoo', 'about', 'bob']
In [4]:
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
Out[4]:
['about', 'bob', 'Credit', 'Zoo']
In [5]:
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
Out[5]:
['Zoo', 'Credit', 'bob', 'about']
1.1.0.2 Python类中有哪些的成员，如何分类他们，他们各自又有哪些用途？
成员变量分为局部变量和全局变量
局部变量：
1.函数内部定义的变量
2.不同函数内的局部变量可以定义相同的名字，互不影响。
3.作用范围：函数体内有效，其它函数不能直接使用。
全局变量
1.函数外部定义的变量
2.作用范围：可以在不同函数中使用
3.函数内使用global关键字实现修改全局变量的值。
成员函数：
带返回值的函数
多返回值函数
匿名函数 可以作为参数被传入其他函数。
1.1.1 Python中列表，元组的相同之处及区别都有哪些？集合与字典呢？
列表：
列表list，用中括号“[ ]”表示
1.任意对象的有序集合
列表是一组任意类型的值，按照一定顺序组合而成的
2.通过偏移读取
组成列表的值叫做元素(Elements)。每一个元素被标识一个索引，第一个索引是0，序列的功能都能实现
3.可变长度，异构以及任意嵌套
列表中的元素可以是任意类型，甚至是列表类型，也就是说列表可以嵌套
4.可变的序列
支持索引、切片、合并、删除等等操作，它们都是在原处进行修改列表
5.对象引用数组
列表可以当成普通的数组，每当用到引用时，Python总是会将这个引用指向一个对象，所以程序只需处理对象的操作。当把一个对象赋给一个数据结构元素或变量名时，Python总是会存储对象的引用，而不是对象的一个拷贝
元组：
1.任意对象的有序集合
与列表相同
2.通过偏移存取
与列表相同
3.属于不可变序列类型
类似于字符串，但元组是不可变的，不支持在列表中任何原处修改操作，不支持任何方法调用
4.固定长度、异构、任意嵌套
固定长度即元组不可变，在不被拷贝的情况下长度固定，其他同列表
5.对象引用的数组
与列表相似，元祖是对象引用的数组
tuple和list相比,元祖tuple有以下特点
1.比列表操作速度快
2.对数据“写保护
3.可用于字符串格式化中
4.可作为字典的key
- 代码题
1、创建一个函数，接收一个字符串参数，判断其做为Python标识符是否合法。
具体要求：
- 如果合法则输出 True，否则输出 False。
- 如果该字符串与Python内置的关键字，或Bifs冲突，则打印'conflict'
- 注: Python标识符的规则，关键字和Bifs可搜索得到
import keyword, string
print(keyword.kwlist)
print()
print(string.ascii_letters)
print()
print(string.digits)['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else',
'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
'return', 'try', 'while', 'with', 'yield']
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
0123456789 import keyword, string
def Identifier(s):
kw = keyword.kwlist # 内置关键字
# 请用if-else完成检测，打印conflict或者False
# your code here
# 标识符命名规范
# 1.数字，下划线，字母构成
# 2.避开关键字，这里s != kw
# 3.不能用数字开头
# 不能是关键字
if s in kw:
print(s, "标识符不能是关键字")
return False
# 开头必须是字母或者下划线
elif s[0] == "_" or s[0] in string.ascii_letters:
# 除开头以外，必须是数字+下划线+字母
for i in s[1:]:
if (i == "_") or (i in string.digits) or (i in string.ascii_letters):
pass
else:
print(s, "既不是关键字，开头也合法，但是后面有非法字符")
return False
print(s, "合法的标识符")
return True
else:
print(s, "不是关键字，开头已经不合法(后面不晓得)")
return False
print("01", Identifier("list"))
print("02", Identifier("abc#"))
print("03",Identifier("1a"))list 合法的标识符
01 True
abc# 既不是关键字，开头也合法，但是后面有非法字符
02 False
1a 不是关键字，开头已经不合法(后面不晓得)
03 False2、编写一个函数，能生成包含20个随机整数的列表，然后将前10个元素升序排列，后10个元素降序排列，并分别打印输出
提示：本题考察对列表的切片和排序操作，注意切片下标。
import random
def sort2part():
# 用random生成20个随机数并完成本题要求
# your code here
# 创建一个列表用于保存随机数
total_list = []
list_asc = []
list_dec = []
# 1、生成20个随机数
for i in range(20):
total_list.append(random.randint(1, 20))
print("生成的随机数列表是这个样子：", total_list)
# 2、对列表进行切片
list_asc = total_list[:10]
list_dec = total_list[10:]
print("切片后前10的列表:", list_asc)
print("切片后后10的列表:", list_dec)
assert len(list_asc) + len(list_dec) == len(total_list), "长度需要满足一致"
# 3、分别进行排序
list_asc = sorted(list_asc)
list_dec = sorted(list_dec, reverse=True)
print("升序后前10的列表:", list_asc)
print("降序后后10的列表:", list_dec)
return
sort2part()3、有一分数序列为：2/1，3/2，5/3，8/5，13/8，21/13, 请使用Python代码生成，并打印该数列的前30(演示代码取5项)项，并求和返回
提示：观察分数的分子和分母，每1项都和前2项有关系，也可检索“斐波那契数列”
# 显示分数的包
import fractions
from functools import reduce
def fab(max_num):
# 完成分子分母的生成并计算求和返回结果
# your code here
# 创建列表保存数据
_list = []
# 1、首先生成斐波那契数列
a = 1 # 注意这里a从1开始
b = 1
for i in range(max_num):
# a是分母，b是分子
a, b = b, a + b
'''
上式等同于下面3式：
temp = b
b = a + b
a = temp
'''
# print("a = ", a, "b = ", b)
# 2、生成分数
_list.append(fractions.Fraction(b, a))
# _list.append(b / a)
print("看一眼生成的列表长啥样：", _list)
# 分数要遍历才能打印...
for elm in _list:
print(elm)
assert len(_list) == max_num, "长度一致"
# 3、求前30项的和
sum_ = reduce(lambda x, y: x + y, _list)
return sum_
print("该数列的前5项和: ",fab(5))看一眼生成的列表长啥样： [Fraction(2, 1), Fraction(3, 2), Fraction(5, 3), Fraction(8, 5), Fraction(13, 8)]
2
3/2
5/3
8/5
13/8
该数列的前5项和: 1007/120 4、BMI编写
身体质量指数（BMI）是根据人的体重和身高计算得出的一个数字，BMI是可靠的身体肥胖指标，其计算公式：BMI = Weight / High2，其中体重单位为公斤，身高单位为米。
- 计算公式为： B M
I
体 重 （ -
提示用户输入体重（kg）和身高的数字(m)(注意单位），然后计算BMI。
-
根据BMI指数范围，定义当前健康状态。BMI指数在18至25之间定义为健康的标准体重, 小于该范围定义为偏瘦，超过该范围定义为偏重。
-
将BMI指数和其所代表状态输出
weight = float(input('请输入您的体重：'))
high = float(input('请输入您的身高：'))
# 完成BMI计算并返回结果提示信息
# your code here
high = high / 100
BMI = weight / (high ** 2)
if 18 <= BMI <= 25:
print("您的身体质量指数是：%.2f, 很健康哦" % BMI)
elif BMI < 18:
print("您的身体质量指数是：%.2f, 有些偏瘦哦" % BMI)
else:
print("您的身体质量指数是：%.2f, 你这个胖纸" % BMI)请输入您的体重：65
请输入您的身高：173
您的身体质量指数是：21.72, 很健康哦5、字符统计
- 创建一个函数，接收字符串输入，分别统计出其中英文字母、空格、数字和其它字符的个数后打印。
-
提示：
-
ord('a') 能将字符 'a' 转化为 ASCII 码表上对应的数值，
- 例如，空格为32
- 数字 0-9 对应的码值为 48-57
- 大写字母 A-Z 对应 65-90
- 小写字母 a-z 对应 97-122
- 比122高的都是其它。
def str_count(s):
# 完成对应要求的统计，并返回对应的数量
# your code here
# 初始化计数变量
count_s, count_z, count_a, count_o = 0, 0, 0, 0
for i in s:
# 得到对应ASCII码的数值
num_asc = ord(i)
if num_asc == 32:
count_s += 1
elif 48 <= num_asc <= 57:
count_z += 1
elif 65 <= num_asc <= 90 or 97 <= num_asc <= 122:
count_a += 1
elif num_asc > 122:
count_o += 1
# assert (count_s + count_z + count_a + count_o) == total_num, "最终个数相符"
print("空格个数：%d个" % count_s)
print("数字个数：%d个" % count_z)
print("英文字母个数：%d个" % count_a)
print("其他字符个数：%d个" % count_o)
str_count("我是xiao ming ming, 今年27岁")空格个数：3个
数字个数：2个
英文字母个数：12个
其他字符个数：5个6、创建一个函数，可以将去除给定列表中中相邻且重复的元素(只保留一个)后，打印输出结果。
-
说明
-
输入参数为 l1 = 1,2,3,4,4,4,4,4,4,5,6,6,8,8,12,12,12,12,13
- 操作后，保证原有整体排序不变，仅处理相邻且重复的元素
- 请勿使用set
def remove_same(ll):
# 完成题目要求的任务，并返回结果
# your code here
# 逆序,这样就不会出现下标溢出的情况
for i in range(len(ll) - 1, 0, -1):
# print("现在到了第%d步" % i)
print(ll)
if ll[i] == ll[i-1]:
# 删除相邻且重复的元素
del ll[i]
return ll
lst = [4,4,5,6,5,6,6,8,7,8,12,12]
# lst = [1,1,2,3,4,4,4,4,4,4,5,6,6,8,8,12,12,12,12,13]
# lst1 = [1,2,3,4,4,4,4,4,4,5,6,6,8,8,12,12,12,12,13, 4, 8, 4, 12, 13, 13, 17, 3, 3, 3]
print(remove_same(lst))[4, 4, 5, 6, 5, 6, 6, 8, 7, 8, 12, 12]
[4, 4, 5, 6, 5, 6, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 8, 7, 8, 12]
[4, 4, 5, 6, 5, 6, 8, 7, 8, 12]
[4, 5, 6, 5, 6, 8, 7, 8, 12]7、创建一个函数，接收一个由整数组成的列表（需对输入列表做检查，长度最少为2, 数据类型为整型），并检验后下列条件后输出：
- 如列表是升序排列的,则输出"ASC";
- 如列表是降序排列的,则输出"DESC";
- 如列表无序，则输出"WRONG"。
def check_data(l):
# 请完成题目要求的任务，并输出对应信息
# your code here
# 得到列表的总长度
count = len(l)
if count < 2:
print("长度不够，短拒")
return None
# 判断数据类型是否位int
for i in range(count):
if not isinstance(l[i], int):
print("数据类型有非int型")
return None
# 判断是否是升序
if sorted(l) == l:
print("ASC")
# 判断是否降序
elif sorted(l, reverse=True) == l:
print("DESC")
# 无序
else:
print("WRONG")
check_data([1])
check_data([1,"2"])
check_data([1,2,3,4])
check_data([4,3,2,1])
check_data([1,3,2,4])长度不够，短拒
数据类型有非int型
ASC
DESC
WRONG8、高阶函数综合运用
l1=1,3,6,8,10,11,17
请仅使用map,reduce,filter对上方数组依次进行如下三次操作：
-
剔除掉所有的偶数后打印
-
对剩下的数字每个数字进行平方后打印
-
对数组求和后打印
# 剔除掉所有的偶数后打印
# your code here
l1=[1,3,6,8,10,11,17]
print("原始的l1:", l1)
def f(x):
return x % 2 != 0
l1 = list(filter(f, l1))
print("剔除偶数后的l1:", l1)原始的l1: [1, 3, 6, 8, 10, 11, 17]
剔除偶数后的l1: [1, 3, 11, 17]# 对剩下的数字每个数字进行平方后打印
# your code here
print("现在的l1:", l1)
l1 = list(map(lambda x: x ** 2, l1))
print("求平方后的l1:", l1)现在的l1: [1, 3, 11, 17]
求平方后的l1: [1, 9, 121, 289]# 对数组求和后打印
# your code here
print("现在的l1:", l1)
# 对数组中国的数求和
from functools import reduce
l1_sum = reduce(lambda x, y: x + y, l1)
print("所求数字之和：", l1_sum)现在的l1: [1, 9, 121, 289]
所求数字之和： 420 9、Python类设计
设计一个公司类，完成以下要求， 并实例化不同对象进行验证
类变量
- 类下公司的总个数，类下公司实例的名称列表
类方法
- 返回公司类共有多少个公司实例
- 返回公司类的公司实例有名称列表
实例变量
- 公司名，简介，利润，销售额，总成本，雇员姓名列表，雇员详细信息列表(这里可能会考察到*号对参数解包)
实例方法：
- 招聘人才（每招一个人会有成本产生，影响该实例雇员列表、人数、总成本，默认成本cost=10000）
- 解雇人员（每解雇一个人会有成本产生，影响该实例雇员列表、人数 、总成本，默认成本cost=5000）
- 公司广告推广(影响该实例总成本，自定义成本cost)
- 交社保(按公司雇员总人数计算，影响该实例总成本，默认单人社保缴纳1000)
- 交税(按公司雇员总人数计算，影响该实例总成本，默认单人税费缴纳500)
- 销售（按销售件数*价格计算销售额，利润按销售额*利润率进行计算利润。默认利润率50%）
- 获取公司雇员列表
- 获取公司净利润
提示：具体的函数方法与变量定义，请参考下述实例化代码确定。初始化雇员的地方，大家看到调用的时候会包含年龄等信息，这里可能会用到不定长参数输入，详细可以参考python参数说明(https://blog.csdn.net/qinyilang/article/details/5484415)
class Company(object):
# 完成题目对应的要求
# your code here
# 类变量: 类下公司的总个数，类下公司实例的名称列表
companyNum = 0
companyList = []
def __init__(self, companyName, brief, profit=0, sale_=0, cost=0, name_list=[], *args):
'''
实例变量
公司名，简介，利润，销售额，总成本，雇员姓名列表，雇员详细信息列表(这里可能会考察到*号对参数解包)
'''
# 公司名
self.companyName = companyName
# 简介
self.brief = brief
# 利润，销售额，总成本，雇员姓名列表，雇员详细信息列表
self.profit = profit
self.sale_ = sale_
self.cost = cost
self.name_list = name_list
# self.name_detail = name_detail
# 每实例化一个对象，公司数+1
Company.companyNum += 1
# 每实例化一个对象，公司实例的名称列表追加一个公司名
Company.companyList.append(self.companyName)
def recruit(self, name, age, cost=10000):
'''
招聘人才
每招一个人会有成本产生，影响该实例雇员列表、人数、总成本，默认成本cost=10000
'''
self.name_list.append(name)
self.cost += cost
# self.name_detail.append(age)
def dismiss(self, name, cost=5000):
'''
解雇人员
每解雇一个人会有成本产生，影响该实例雇员列表、人数 、总成本，默认成本cost=5000
'''
self.name_list.remove(name)
self.cost -= cost
def adPromotion(self, cost):
'''
公司广告推广
影响该实例总成本，自定义成本cost
'''
self.cost += cost
def payInsurance(self):
'''
交社保
按公司雇员总人数计算，影响该实例总成本，默认单人社保缴纳1000
'''
self.cost -= 1000 * len(self.name_list)
def payTax(self):
'''
交税
按公司雇员总人数计算，影响该实例总成本，默认单人税费缴纳500
'''
self.cost -= 500 * len(self.name_list)
def sale(self, num, price):
'''
销售
按销售件数*价格计算销售额，利润按销售额*利润率进行计算利润。默认利润率50%
'''
# 销售额
self.sale_ = num * price
# 利润
self.profit += self.sale_ * 0.5
def getEmployeeList(self):
'''
获取公司雇员列表
'''
return self.name_list
def getProfit(self):
'''
获取公司净利润
'''
# 利润 = 收入 - 支出
# 收入
return self.profit - self.cost
# 类方法
# 返回公司类共有多少个公司实例
# 返回公司类的公司实例有名称列表
@classmethod
def Company_num(cls):
return len(cls.name_list)
@classmethod
def Company_list(cls):
return cls.name_list#功能验证
c0 = Company('网易','高科技互联网公司')
c0.recruit('张三',18, cost=20000)
c0.recruit('王五',20, cost=10000)
print('{}公司员工详细信息列表:{}'.format(c0.companyName, c0.getEmployeeList()))
c0.dismiss('王五')
c0.adPromotion(5000)
c0.payInsurance()
c0.payTax()
c0.sale(50,100)
print('{}公司员工详细信息列表:{}'.format(c0.companyName, c0.getEmployeeList()))
print('{}公司当前利润：{}'.format(c0.companyName, c0.getProfit()))
c1 = Company('百度','搜索引擎')
c1.recruit('李四',30, cost=50000)
c1.recruit('赵六',50, cost=40000)
print('{}公司员工详细信息列表:{}'.format(c1.companyName, c1.getEmployeeList()))
print('公司名列表：',Company.companyList)
print('公司总个数：',Company.companyNum)网易公司员工详细信息列表:['张三', '王五']
网易公司员工详细信息列表:['张三']
网易公司当前利润：-26000.0
百度公司员工详细信息列表:['张三', '李四', '赵六']
公司名列表： ['网易', '百度']
公司总个数： 210、结合PIL库，制作一个能生成5位随机数验证码图片的函数
生成5位随机数验证码并存储为verify.png名称的图片。
提示：PIL库的使用方法可以参考python中PIL库的使用和PIL库简易教程与验证码生成
%matplotlib inline
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
from PIL import ImageFilter
import random
# 完成题目指定的任务
# your code here
# 随机ASCII码生成数字
def rndChar():
return chr(random.randint(48, 57)) # 0-9的ASCII码是48-57
# 随机颜色1:
def rndColor():
return (random.randint(64, 255), random.randint(64, 255), random.randint(64, 255))
# 随机颜色2:
def rndColor2():
return (random.randint(32, 127), random.randint(32, 127), random.randint(32, 127))
# 300 x 60:
num = 5 # 生成num位的验证码
width = 60 * num # 图宽
height = 60
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(num):
draw.text((60 * t + 10, 10), rndChar(), font=font, fill=rndColor2())
# 模糊:
image = image.filter(ImageFilter.BLUR)
image.save("verify.png", "jpeg")
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
