Python相关知识点

1. lambda 表达式(又称匿名函数)

作用：
　　　　创建一个匿名函数对象
　　　　用def 类似，但不提供函数名
　　　语法格式：

lamdba [形参1,形参2,…]:表达式
　　　例：
def myadd(a,b):
return a + b
|| #等同于
myadd = lamdba a, b: a + b # 表达式

print('10 + 20 =',myadd(10,20))
print('30 + 40 =',myadd(30,40))　

说明：

1.lambda 只是一个表达式，它用来创建一个函数对象
　　　　2.当lambda表达式调用时，先执行冒号(😃
后的表达式，并返回表达式的结果的引用
3.lambda 表达式创建的函数只能包含一条表达式
4.lambda比函数简单且可以随时创建和销毁，有利于减少程序的偶合度

2.函数式编程

是指用一系列函数解决问题

函数是一等公民(Guido)
1.函数本身可以赋值给变量,赋值后变量绑定函数
2.允许将函数本身作为参数传入另一个函数
3.允许函数返回一个函数

3.递归函数 recursion

函数直接或间接的调用自身

例：
　def f():
f() #直接调用自己，进入递归
f()

#函数间接调用自身
def fa():
    fb()
def fb():
    fa()
fa()
print("递归完成")

说明：
　　递归一定要控制递归的层数，当符合一定条件时要终止递归
　　调用
　　几乎所有的递归都能用while循环来代替

优点：
　　递归可以把问题简单化，让思路更为清晰，代码更简洁
缺点：
　　递归因系统环境影响大，当递归深度太大时，可能会得到不
　　可预知的结果

递归的两个阶段：
　　　　递推阶段：　从原问题出发，按递归公式递推从未知到已知，
　　　　　　　　　　　　　　最终达到递归的终止条件
　　　　回归阶段：　按递归终止条件求除结果，逆向逐步代入递归公式
　　　　　　　　　　　　　　，回归到问题求解

例：
def fn(n):
print(‘递归进入第’,n,‘层’)
if n == 3: #当递归进入第三层时，将不再向下走，开始回归
return
fn(n+1)
print(‘递归退出第’,n,‘层’)

fn(1)
print(‘程序结束’)

列：
def myfac(n):
if n == 1:
return 1
return n * myfac(n-1)
print(‘5的阶乘是:’,myfac(5))

4.闭包 closure

闭包是指引用了此函数外部嵌套函数作用域变量的函数

闭包必须满足三个条件：
　　　1.必须有内嵌函数
　　　2.内嵌函数必须引用外部函数中的变量
　　　3.外部函数返回值必须是内嵌函数.

例子：
　　def make_power(y):
def fn(x):
return x ** y
return fn

pow2 = make_power(2)
print(‘5的平方是:’,pow2(5))
pow3 = make_power(3)
print(‘6的立方是:’,pow3(6))

5.装饰器 decorators

什么是装饰器
　　　　装饰器是一个函数，主要作用是用来包装另一个函数或类(后面会讲)
作用：
　　是在不改变原函数名(或类名)的情况下改变被包装对象的行为

函数装饰器：
　　　　　函数装饰器是指装饰器是一个函数，传入的是一个函数，返回的也是一个函数

语法：
　　def 　装饰器函数名(参数)：
　　　　　　　语句块
　　　　　　　return 函数对象

＠装饰器函数名<换行>
def 函数名（形参列表）：
　　　　语句块

例：

def mydeco(fn):
def fx():
print(‘fx函数被调用’)
return fx
# myfunc加了mydeco装饰器，等同于在myfunc创建之后调用
# myfunc = mydeco(myfunc)
　　　　@mydeco
def myfunc():
print(‘函数myfunc被调用’)

#myfunc = mydeco(myfnc) #这样的写法可以用装饰器来代替
myfunc() #这里调用谁？

def mydeco(fn):
def fx():
print(‘+++++++++这是myfunc调用之前’)
fn()
print(‘---------这是myfunc调用之后’)
return fx
@mydeco
def myfunc():
print(‘函数myfunc被调用’)
myfunc()

python相关问题

1、 python2中乱码如何解决(这个是python2的问题)

	答：通过使用UNICODE字符集可以满足跨语言文字处理，避免乱码的产生。

2、 python的垃圾回收机制是什么，引用计数。

	答：在引用计数基础上，还可以通过“标记-清除”解决容器对象可能产生的循环引用的问题，也可以用“分代回收”以空间换取事件
	来进一步提高垃圾回收的效率。

3、函数作用域

	答： * 如果一个变量在def内赋值，则被定位在这个函数内
		 * 如果一个变量在一个嵌套函数的def中赋值，对于嵌套函数来说，它非本地的
		 * 如果一个变量在def外赋值，它就是整个文件

4、常用的python模块有哪些？

	答：
		* time(时间)
		* random(随机数)
		* os模块(提供对操作系统进行调用的接口)
		* json模块(用于字符串和python数据类型间进行转换)

5、常用的Linux命令有哪些

	答：
		* cd(进入一个目录下)
		* pwd(显示工作路径)
		* ls(查找文件)
		* tree(显示文件和目录由根目录开始的树形结构)
		* mkdir(创建文件夹)
		* rm(删除)
		* mv(重命名/移动一个目录)
		* cp(复制一个文件)
		* touch(修改一个文件或目录的时间戳)
		* find(文件搜索)
		* tar,zip(打包，解压)
		* chomd(设置权限)

6、函数里一个*和两个**是什么意思？

	答：
	 	  一个*表示计算，两个**表示参数传递过程中元素的打包和解包。

7、线程和进程的问题，全局解释器锁。

	答：
		* 线程：是程序执行流的最小单元，是系统独立调度和分配CPU(独立运行)的基本单位。
		* 进程：是资源分配的基本单位，一个进程包括多个线程。
		* 多线程：同一时刻执行多个线程。
		* 多进程：同时执行多个程序。
		* GIL锁，全局解释器，作用就是限制多线程同时执行，保证同一时间内只有一个线程在执行。

8、python支不支持char类型

	答：不支持

9、列表的常用函数

	答：
		* List.append(添加元素)
		* List.insert(插入一个元素)
		* List.remove()(删除元素)
		* List.pop()(弹出某个元素)
		* List.reverse()反转
		* List.sort()排序

10、字典的常用函数

	答：
		* dict()创建空字典
		* keys()字典的键为不可变的类型
		* vlaues()字典的值可以为任意类型，任意值。

11、python里的数据类型

	答：
		* Number(数字)
		* String(字符串)
		* List(列表)
		* Dict(字典)
		* Tuple(元祖)
		* Set(集合)
		* 不可变数据：Number、String、Tuple
		* 可变数据：List、Dict、Set

12、字典和列表的区别，列表和元组的区别。

	答：
		* 列表是任意对象的有序集合，列表是一组任意类型的值，按照一定顺序组合而成的。
		* 字典是任意对象的无序集合，字典中没有特定顺序，以“键”为象征。
		* 列表是动态数组，可以改变内部元素的个数
		* 元组是静态数组，内部元素一旦创建便无法改变

13、什么是lambda表达式，作用。

	答：
		* lambda只是一个表达式(又称匿名函数)，用来创建一个函数对象
		* 作用可以随时创建和销毁，有利于减少程序的耦合度

14、pass语句的作用是什么？

	答：pass语句，又称空语句，填充语法空白

15、python中如何拷贝一个对象

	答：赋值、浅拷贝、深拷贝。

16、python中如何生成一个随机数？返回数据时什么类型？

	答：random函数，返回浮点数。

17、python中"is" 和 "==" 的区别？

	答："is"比较的是id，"=="比较的是vlaue值

18、python的函数重载主要解决什么问题？

	答：
		* 可变参数类型
		* 可变参数个数

19、cookie和session的区别？

	答：
		* cookie数据保存在客户浏览器上，cookie不是很安全
		* session数据放在服务器上，session会在一定时间内保存在服务器上。

20、当一个类继承多个类时，集成的顺序时什么样的？

	答： 自下而上的

21、判断一个文件是否存在，怎么判断一个文件是文件还是普通文件。

	答：os模块中的os.path.exists()方法用于检验文件是否存在。

22、对python的理解

	答：
		* python是一种解释性语音
		* python是动态语言，在创建新的变量时，不用去指定变量的类型
		* python是面向对象的语言
在 Python 中生成一个随机字母

这篇文章将讨论如何在 Python 中生成随机字母。

在里面 以前的帖子，我们已经讨论了如何在 Python 中生成随机数。这篇文章概述了在 Python 中生成随机字母的几个函数。

1.使用 random.choice() 功能
这 random.choice() 函数用于从指定的序列中选择一个随机项。这个想法是使用 ascii_letters 从常数 string 模块，它返回一个包含范围的字符串 A-Za-z，即小写和大写字母。

import string, random

if name == ‘main’:

rand = random.choice(string.ascii_letters)
print(rand)

2.使用 secrets.choice() 功能
如果您需要生成加密安全的随机字母，请考虑使用 choice() 从函数 secrets 模块。

import string, secrets

if name == ‘main’:

rand = secrets.choice(string.ascii_letters)
print(rand)

3.使用 random.randint() 功能
这 random.randint(x, y) 函数生成随机整数 n 这样 x <= n <= y.如果您需要生成一个随机字母，您可以这样做：

import random

在 x - y 范围内生成一个随机字母

def randletter(x, y):
return chr(random.randint(ord(x), ord(y)))

if name == ‘main’:

# 在 `a-z` 范围内生成一个随机字母
r = randletter('a', 'z')

# 在`A-Z`范围内生成一个随机字母
R = randletter('A', 'Z')

#随机选择字母`r`或`R`
rand = (r, R)[random.randint(0, 1)]
print(rand)




# 导入模块

import random
import string

声明字符串长度

string_length = 10

仅生成大写

letters =string.ascii_uppercase
print(‘’.join(random.choice(letters) for i in range(string_length)))

生成大写和数字

letters_digits =string.ascii_uppercase+string.digits
print(‘’.join(random.choice(letters_digits) for i in range(string_length)))

安装第三方库 出现Read timed out的错误

如何解决这种问题，只要在安装第三方库的时候添加时间元素就行了（pip --default-timeout=100 install -U 第三方库名）

获取范围在1-100的随机数字

num = random.randint(1, 100)

num = 8

定义一个变量，记录总共猜测了多少次

count = 0

通过一个布尔类型的变量，做循环是否继续的标记

flag = True
while flag:
guess_num = int(input(“请输入你猜测的数字:”))
count += 1
if guess_num == num:
print(“猜中了”)
# 设置为False就是终止循环的条件
flag = False
else:
if guess_num > num:
print(“你猜的大了”)
else:
print(“你猜的小了”)

print(f"你总共猜测了{count}次")

闭包是什么

答：闭包是指引用了此函外部嵌套函数作用域变量的函数。

实例：

def make_power(y):
def fn(x):
return x ** y
return fn
pow2 = make_power(2)
print(‘5的平方是：’, pow2(5))
pow3 = make_power(2)
print(‘6的平方是：’, pow3(6))

装饰器是什么，用在哪里？

答：装饰器是一个函数，作用是用来包装另一个函数或类

实例：

print(‘下一实例’)
def mydeoc(fn):
def fx():
print(‘myfunc调用之前’)
fn()
print(‘myfunc调用之后’)
return fx
@mydeoc
def myfunc():
print(‘myfunc函数被调用’)
myfunc()
print(‘下一实例’)

实现1到100的相加

实例：

def sum():
sum = 0
for i in range(1,101):
sum += i
return sum
print(sum())
print(‘下一实例’)

什么是迭代器

答：迭代器是访问可迭代对象的工具

# 迭代器是指用iter(obj)函数返回的对象
# 迭代器可以用next(it)函数获取可迭代对象的数据

实例：

L = [2,3,7,9]
it = iter(L)
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(‘下一实例’)

什么是生成器

生成器是能够动态提供数据的对象，生成器对象也是可迭代对象

gen = (i ** 2 for i in range(1,5))
it = iter(gen)
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(‘Str(字符)转换List(列表)’)

Str(字符)转换List(列表)

str1 = ‘12345’
print(str1)
list1 = list(str1)
print(list1)

str2 = “123 world frist”
print(str2)
list2 = str2.split()
print(list2)
print(‘List(列表)转换Str(字符)’)

List(列表)转换Str(字符)

list3 = [“www”,“goole”,“com”]
print(list3)
str3 = “”.join(list3)
print(str3)
str4 = “.”.join(list3)
print(str4)
print(‘List(列表)转换Dict(字典)’)
a = [‘a1’,‘a2’,‘a3’]
b = [‘b1’,‘b2’,‘b3’]
c = zip(a,b)
print(dict©)
print(‘Dict(字典)转换List(列表)’)
dict1 = {‘name’,‘孙悟空’,
‘age’,‘1000’}
list4 = list(dict1)
print(list4)
print(‘List(列表)转换Tuple(元组)’)
list5 = [1,2,3]
tup1 = tuple(list5)
print(tup1)

print(‘下一实例’)

什么是lambda表达式，作用。

lambda只是一个表达式(又称匿名函数)，用来创建一个函数对象

作用可以随时创建和销毁，有利于减少程序的耦合度

实例：

Nick = lambda x,y : x + y
print(Nick(6,9))
print(‘下一实例’)

列表推导式的嵌套

p = [x + y for x in “ABC” for y in “123”]
print§
print(‘下一实例’)

冒泡排序的原理

比较相邻的元素，如果第一个比第二大，就交换他们，每一次只能将一个排序归位，如果有n个数排序，只需要将n-1个数归位。

实例：

def Numbers(nums):
for i in range(len(nums)-1):# 这是循环负责设置冒泡排序进行的次数
for j in range(len(nums)-i-1):# j为列表的下标
if nums[j] > nums[j + 1]:
nums[j],nums[j + 1] = nums[j + 1],nums[j]
return nums
nums = [5,2,45,6,98,16,81]
print(Numbers(nums))
print(‘下一实例’)

递归

def fn(n):
print(‘递归进入第’,n,‘层’)
if n == 5:
return
fn(n + 1)
print(‘递归退出第’,n,‘层’)
fn(1)
print(‘程序结束’)
print(‘下一实例’)

列表的排序方法

list内置sort()方法用来排序，也可以用python内置的全局sorted()方法来对可迭代的序列排序生成新的序列

实例：

list5 = sorted([19,5,16,2,8,6])
print(list5)

list6 = [5,3,1,7,2]
list6.sort()
print(list6)
list6.reverse()# 反转
print(list6)

list7 = sorted({5:‘D’,3:‘B’,4:‘C’,2:‘A’,1:‘E’})
print(list7)