python 面试
Posted 九友
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python 面试相关的知识，希望对你有一定的参考价值。
# a = [‘him‘, 25, 100, ‘her‘, 100, 25]
# print(a)
# print(a[1:3])
# a[0]=9
# print(a)
# print(25 in a)
# print(set([2, 4]) <= set(a))
# print(set(a))
"""
a = set(‘abracadabra‘)
b = set(‘alacazam‘)
print(a)
print(b)
print(a-b)
print(a&b)
print(a^b) #a和b中不同时存在的数据
a = [‘him‘, 25, 100, ‘her‘, 100, 25]
#判断多个值，那么就要用到set
print(set([25, 100]) <= set(a))
"""
"""
dic = {}
tel = {‘abc‘: 1320,‘tom‘: 1998}
print(tel)
print(tel[‘abc‘]) #查询键值
tel[‘name‘]= 1980 #添加键值
print(tel)
"""
# In[]
x = dict([(‘sape‘, 4139), (‘guido‘, 4127), (‘jack‘, 4098)])
print(x)
print(dict(abc=123,datoou=456,name=789))
# In[]
s = ""
for i in range(1):
while True:
v1 = input(‘用户名‘)
v2 = input(‘密码‘)
v3 = input(‘邮箱‘)
template = "{0} {1} {2}
"
v = template.format(v1,v2,v3)
s = s + v
break
print(s)
# expandtabs 意思为将字符串中的TAB符号（
）转换为空格，默认是8个空格
print(s.expandtabs(20))
kvps = {‘1‘:1,‘2‘:2}
theCopy = kvps.copy() # 相当于复制一份，而且原来的改变并不影响复制后的
kvps[‘1‘] = 5
sum = kvps[‘1‘]+theCopy[‘1‘]
print(sum)
import pylab as pl
import numpy as np
import pandas as pd
df = pd.read_csv(‘E://data//数据集 (2).csv‘)
df.describe() # 数据的基本信息
df.std() # 数据每一列的标准差
# 将分类变量进行整理
dummy_ranks=pd.get_dummies(df[‘Property_Area‘],prefix=‘Property_Area‘)
dummy_ranks.head()
dummy_ranks1 = pd.get_dummies(df[‘Dependents‘],prefix = ‘Dependents‘)
dummy_ranks1.head()
# 将分类好的数据进行合并
cols_to_keep = [‘Credit_History‘,‘Gender‘,‘Married‘,‘Education‘,‘Self_Employed‘, ‘Loan_Amount_Term‘,‘LoanAmount‘,‘ApplicantIncome‘,‘CoapplicantIncome‘]
data = df[cols_to_keep].join(dummy_ranks.ix[:, ‘Property_Area_1‘:])
da = data.join(dummy_ranks1.ix[:, ‘Dependents_1‘:])
# 添加逻辑回归所需要的变量
data[‘intercept‘] = 1.0
# 指定作为训练变量的列，不含目标列`Credit_History`
train_cols=da.columns[1:]
import statsmodels.api as sm
logit = sm.Logit(da[‘Credit_History‘],da[train_cols])
#拟合模型
result=logit.fit()
result.summary() # 模型系数的特征
result.conf_int() # 查看每个系数的置信区间
np.exp(result.params) # 相对危险度（ odds ratio），可知变量每单位的增加、减少对该客户违约几率影响。 ，
# 使用95%的置信区间来估算出一个系数变化对信用的影响程度
params = result.params
conf = result.conf_int()
conf[‘OR‘] = params
conf.columns = [‘2.5%‘, ‘97.5%‘, ‘OR‘]
np.exp(conf)
# In[]
df = pd.read_csv(‘E://data//数据集 (2).csv‘)
dummy_ranks=pd.get_dummies(df[‘Property_Area‘],prefix=‘Property_Area‘)
dummy_ranks.head()
dummy_ranks1 = pd.get_dummies(df[‘Dependents‘],prefix = ‘Dependents‘)
dummy_ranks1.head()
# 将分类好的数据进行合并
cols_to_keep = [‘Credit_History‘,‘Education‘,‘Self_Employed‘, ‘Loan_Amount_Term‘,‘LoanAmount‘]
data = df[cols_to_keep].join(dummy_ranks.ix[:, ‘Property_Area_1‘:])
da = data.join(dummy_ranks1.ix[:, ‘Dependents_1‘:])
# 添加逻辑回归所需要的变量
data[‘intercept‘] = 1.0
# 指定作为训练变量的列，不含目标列`Credit_History`
train_cols=da.columns[1:]
import statsmodels.api as sm
logit = sm.Logit(da[‘Credit_History‘],da[train_cols])
#拟合模型
result=logit.fit()
result.summary() # 模型系数的特征
# In[]
# 将列表的元素 按照首字母进行分类存储 格式为存储在列表中 每一类以元组的形式整合到列表中
"""
分析： 首先转换为字典格式 以首字母为键值存储一类的数据
在将字典中的每一类的数据转换为元祖存储到列表当中
元组的增加 ------ a+(i,)
"""
a = [‘a1‘,‘a2‘,‘b1‘,‘b2‘,‘c1‘]
s = {}
# 将相同的部分转换为列表
for i in a:
l = i[0]
if l in s:
s[l].append(i)
else:
s[l] = [i]
s
# 将相同的部分转换为元组
for i in a:
if i[0] in s.keys(): # 提取首字母 查询首字母是否存在于集合的键值中
# 如果存在 就在该键值的后面追加同一类的数据
s[i[0]] = s[i[0]]+(i,)
else:
# 如果不存在 就以该键值创建 并且将对应的数据存储到该键值的后面
s.update({i[0]:(i,)})
a = [‘a1‘,‘a2‘,‘a3‘,‘b1‘,‘b2‘,‘b3‘,‘c3‘,‘c4‘,‘c5‘,‘d2‘,‘f3‘]
s = {}
for i in a:
# 和上面的区别在于判断如果不存在就创建
if i[0] not in s.keys():
s.update({i[0]:(i,)})
else:
s[i[0]] = s[i[0]]+(i,)
print(s[i[0]])
a = [[None]*2]*3
a[0][0] = 3
# In[]
d1 = {‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘, ‘k3‘: ‘v3‘}
d2 = {‘k1‘: ‘v1_1‘, ‘k3‘: ‘v3_3‘, ‘k4‘: ‘v4‘}
print(list(map(lambda k: (d1[k], d2[k]), {*d1} & {*d2})))
# 将集合中的键值按照从大到小的顺序排列
a={1:1,2:2,3:3}
sorted(a.keys(),reverse = True)
sorted(a.values(),reverse = True)
print(‘,‘.join(map(str,sorted(a.keys(),reverse = True))))
s = {x:x.strip() for x in (‘ he ‘,‘ she ‘,‘ i ‘)}
s
# In[]
"""
赋值 浅复制 深复制的区别：
"""
n = [4,5,6]
a = [1,2,3,n]
id(a)
id(n)
x = a
id(x)
id(x[3])
import copy
s = a.copy()
id(x)
id(s[3])
b = copy.deepcopy(a)
id(b)
id(b[3])
a = [1,2,3,4,3,3]
set(a)
b = list(set(a)) # 利用集合的不重复性进行去重
b
#集合的CRUD -- create rund update deleter
#这里需要注意的是，当用set() 函数声明一个多元素的集合时，必须用小括号括起来
my_set = set(("Neo","Fiarter","Haner"))
print(my_set)
#添加元素
my_set.add("Tom")
print(my_set)
#移除元素
my_set.remove("Neo")
print(my_set)
#统计长度
print(len(my_set))
#清空
my_set.clear()
print(my_set)
# In[]
# 查看字典中常用的方法
dir(dict)
print("Hello‘GreedyAI") #输出一个实际的单引号 ‘
print("Hello"GreedyAI") #输出一个实际的双引号 “
print("Hello
GreedyAI") #输出一个实际的换行符/回车
print("Hello GreedyAI") #输出一个实际的 tab 制表符
print("Hello\nGreedyAI") #输出原始的字符串
print(r"Hello
GreedyAI") #输出原始的字符串
print(R"Hello
GreedyAI") #输出原始的字符串
print("Hello World".find("Hello")) #输出结果0
print("Hello World".find("e")) #输出结果1
print("Hello World".find("W")) #输出结果6
# 冒泡排序法
a = [5,3,15,18,68,1024]
for i in range(len(a)-1): #外层循环控制循环次数
for j in range(len(a)-1-i): #内层循环，控制每循环一次，比较的次数逐次-1
if a[j] > a[j+1]: #比较两个数字的大小条件
a[j],a[j+1] = a[j+1],a[j] #左右交换
print(a) #输出 [3,5,15,18,68,1024]
import heapq
p=[{‘name‘:‘ibm‘,‘shares‘:100,‘prices‘:91.11},
{‘name‘:‘apple‘,‘shares‘:50,‘prices‘:543.31},
{‘name‘:‘t‘,‘shares‘:150,‘prices‘:21.51},
{‘name‘:‘mi‘,‘shares‘:30,‘prices‘:441.16},
{‘name‘:‘360‘,‘shares‘:10,‘prices‘:61.81},
{‘name‘:‘car‘,‘shares‘:80,‘prices‘:221.51}
]
#s:要排序的元素
#s[‘prices‘]以元素的key=[‘prices‘]进行排序
cheap=heapq.nsmallest(3,p,key=lambda s:s[‘prices‘])
expensive=heapq.nlargest(3,p,key=lambda s:s[‘prices‘])
print(cheap,‘
‘,expensive)
# In[]
# os模块的了解
import os
import time
os.path.basename(‘/root/abc.txt‘) # 返回文件名
os.path.dirname(‘/root/abc.tst‘) # 返回目录的路径
os.path.split(‘/root/abc.txt‘) # 分割文件名与路径
os.path.join(‘root‘,‘abc‘,‘tst‘) # 连接文件名和路径
file= r"D:python_pycharm代码国赛.py"
a = os.path.getatime(file) # 获取当前文件夹的最近访问时间
time.gmtime(a) # 将上面得到的时间转换为时间戳格式
time.strftime(‘%Y-%m-%d %H:%M:%S‘,time.gmtime(a))
# 将时间戳格式的转换为正常时间里形式
c = os.path.getctime(file) # 获得该文件的创建时间
time.strftime(‘%Y-%m-%d %H:%M:%S‘, time.gmtime(c))
m = os.path.getmtime(file) # 获得最近修改时间
time.strftime("%Y-%m-%d %H:%M:%S" , time.gmtime(m))
print(os.environ)
# In[]
# 字典的增加和删除
a = {‘name‘:‘abc‘,‘age‘:‘19‘}
del a[‘name‘]
b = {‘chengji‘:‘30‘}
a.update(b)
a
# In[]
"""
13、列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，
并使用列表推导式提取出大于10的数，最终输出[16,25]
map（）函数第一个参数是fun，第二个参数是一般是list，
第三个参数可以写list，也可以不写，根据需求
"""
L = [1,2,3,4,5]
map(lambda x:x**2,L)
# 在python3中返回的结果是迭代器 在python2 中返回的是列表
# 所以要想显示 转换为列表格式就可以
a = list(map(lambda x:x**2 , [1,2,3,4,5]))
c = [i for i in a if i > 10]
c = []
for i in a:
if i >10:
c.append(i)
# 生成随机小数 随机整数 0--1之间的小数方法
"""
随机整数：np.random.randint(起始值，结束值，生成个数)
随机小数：利用numpy np.random.rand(5) 生成5个随机小数
0--1 之间小数： random.random() 括号中不传入参数
"""
import numpy as np
np.random.rand(3,2)
np.random.randint(2,10,10)
# In[]
# 正则表达式
import re
"""
<div class="nam">中国</div>，用正则匹配出标签里面的内容（“中国”）
，其中class的类名是不确定的
"""
str = "<div class=‘nam‘>中国</div>"
re.findall(r"<div class=‘.*‘>(.*?)</div>",str)
# 注意其中的标点符号 因为题目告知class的类名不确定 所以使用.*
#.代表可有可无；*代表任意字符，满足类名可有变化
# In[[]
# 数据库去重 select distinct name from student
# 如何实现对python列表去重 并且保持顺序不变
# 先利用集合的不重复性去重 然后再利用初始列表中的序号进行排序
L = [‘cc‘, ‘bbbb‘, ‘afa‘, ‘sss‘, ‘bbbb‘, ‘cc‘, ‘shafa‘]
a = list(set(L))
a.sort(key = L.index)
a
# In[]
# 现有两元组((‘a‘),(‘b‘)),((‘c‘),(‘d‘))
# ,请使用python中匿名函数生成列表
# [{‘a‘:‘c‘},{‘b‘:‘d‘}]
t1 = ((‘a‘),(‘b‘))
t2 = ((‘c‘),(‘d‘))
a = [*zip(t1,t2)]
list(map(lambda x:{x[0]:x[1]},[*zip(t1,t2)]))
# In[]
# 3.在python字符串格式化中,%和.format的主要区别是什么？
"""
% :
python中内置的%操作符可用于格式化字符串的操作
控制字符串的呈现格式，%操作符的使用是最方便的
format：
字符串的format（）函数，该方法收集位置和关键字参数的任意集合
并使用他们的值来替换字符串中的占位符
"""
# In[]
# *args和kwargs在什么情况下会使用到?请给出使用kwargs的示例代码
# *args:表示将实参中按照位置传参,把多出来的值给args,且以元组的方式呈现
def foo(x,*args):
print(x)
print(args)
foo(1,2,3,4,5,6)
# 会将多余的值传递给*args 并以元组的形式展现出来
def foo1(x,**kwargs):
print(x)
print(kwargs)
foo1(1,a = 1, b = 2,c = 3)
# 此时会将多余的值传递给字典 但是传入的时候也需要以字典的形式传入
# In[]
# 字符串x = foo y = 2则x*y的结果为foofoo
x = ‘foo‘
y = 2
print(x*2)
# 赋值:只是调用了地址 其中一个发生变化 另外一个也会发生变化
a = {‘1‘:1,"2":2}
b = a
a[‘1‘] = 5
sum = a[‘1‘]+b[‘1‘]
sum
# 浅复制 ： 会新生成一块内存地址 将父级的值copy到内部
# 但是子级只copy到地址，所以 当父级发生变化时不会影响到另一个
# 子级变另外一个也会改变
import copy
a = [1,2,3,[3,4,5]]
b = a.copy()
# 父级
a[0]= 5
a
b
# 子级
a[3][1]=9
a
b
# 深复制
# 深复制父级和子集完全copy互不影响
import copy
a = [1,2,3,[4,5,6]]
b = copy.deepcopy(a)
b
# In[]
# 添加一个新的搜索路径
# sys.path.append(‘/sds/sd/‘)
# 赋值和[:]不是一回事 在赋值中要注意这一点
names1 = [‘Amir‘,‘Barry‘,‘Chales‘,‘Dao‘]
names2 = names1
names3 = names1[:]
# 这样的赋值 当改变其中的一个另一个并不会改变
names2[0] = ‘Alice‘
names3[1] = ‘Bob‘ #
sum = 0
for ls in (names1,names2,names3):
print(ls)
if ls[0] == ‘Alice‘:
sum += 1
if ls[1] == ‘Bob‘:
sum += 10
print(sum)
# In[]
# 优先级not>and>or
x = True
y = False
z = False
if x or y and z:
print(‘yes‘)
else:
print(‘no‘)
# In[]
# 请写出一段代码 得到列表中的交集和并集以及差集
a = [2,3,4,5]
b = [3,4,5,6]
# 交集
list(set(a).intersection(set(b)))
# 并集,并去重
list(set(a).union(set(b)))
# 差集 : b中有而a中没有的元素
list(set(a).difference(set(b)))
# In[]
# 写出九九表
for i in range(1,10):
for j in range(1,10):
if i>= j:
print((‘%d*%d = %d‘%(j,i,i*j)),end = ‘ ‘)
print()
# 求和1-100
sum(range(1,101))
# 数据类型是否为已知类型
a = [1,2,3,4]
isinstance(a,list)
[i**2 for i in range(1,11)]
# 请写循环 去除列表中的重复值
a = [12,3,4,5,3,4,6,4,2]
b = []
for i in a:
if i not in b:
b.append(i)
else:
continue
print(b)
c = list(set(a))
c.sort(key = a.index)
c
# In[]
# 输入字符串 输出倒序排列的结果
A = ‘1,2,3,4‘
b = A[::-1]
b
# 合并两个列表 并且去除重复的元素
list1 = [2,3,8,4,9,5,6]
list2 = [5,6,10,17,11,2]
set(list1).union(set(list2))
# In[]
# 斐波契纳数列 1,2,3,5,8,13,21......根据这样的规律,编程求出400万
# 以内最大的斐波契纳数,并求出他是第几个斐波契纳数.
li = [1,2]
while li[-1] < 4000000:
li.append(li[-1] + li[-2])
del li[-1]
print(li[-1])
print(len(li))
# In[]
"""
dicta = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4,‘f‘:‘hello‘}
dictb = {‘b‘:3,‘d‘:5,‘e‘:7,‘m‘:9,‘k‘:‘world‘}
要求写一段代码,实现两个字典的相加,不同的key对应的值保留,
相同的key对应的值相加后保留,如果是字符串就拼接,最终得到如下结果：
dictc = {‘a‘:1,‘b‘:5,‘c‘:3,‘d‘:9,‘e‘:7,‘m‘:9,‘f‘:‘hello‘,‘k‘:‘world‘}
"""
dicta = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4,‘f‘:‘hello‘}
dictb = {‘b‘:3,‘d‘:5,‘e‘:7,‘m‘:9,‘k‘:‘world‘}
dic = {}
for key1 in dicta:
for key2 in dictb:
if key1 == key2:
dic[key1] = dicta[key1]+dictb[key2]
for i in dicta:
if i not in dic:
dic[i] = dicta[i]
for j in dictb:
if j not in dic:
dic[j] = dictb[j]
print(dic)
# In[]
# .Python主要的内置数据类型都有哪些?哪些是可变的?哪些是不可变的?可变类型与不可变类型有什么区别？
"""
数字，字符串，列表，字典，布尔型
可变：裂变，字典
不可变：数字，字符串，布尔
可变数据类型：在id不变的情况下，数据类型的内部可以改变
不可变的数据类型： value值改变 id也跟着改变
"""
# In[]
# python是如何进行内存管理的?python的程序会内存泄漏吗?说说有没有什么方面防止或检测内存泄漏?
"""
Python如何进行内存管理?
Python 采用引用计数的方式来管理分配的内存。Python 的每个对象都有一个引用计数，这个引用计数表明了有多少对象在指向它。当这个引用计数为 0 时，释放该对象的内存。为了解决循环引用的问题，Python提供了“标记-清除”法，用于释放循环引用的对象。
为了加速Python的执行效率，Python 同时使用了一个内存池机制，用于管理对小块内存的申请和释放。 Python 的垃圾收集并不会把不用的内存返回给操作系统，而是放到了内存池。对于 int, float, list 对象, Python 还提供了独立的私有内存池。
Python垃圾回收机制,以及在何种情况下会发生内存泄漏
Python 通过引用计数来确定当前变量是否需要释放。每个对象都有一个计数器，当一个对象的引用计数为0时，就会由 gc 模块来执行内存释放操作。假如这个对象在缓冲区内，那么它地址空间不会被释放，而是等待下一次被使用，而非缓冲区的该释放就释放。
对于普通对象 gc 采取分代回收算法，对象根据存活的时间分为三“代”，所有新建的对象都是0代，当0代对象经过一次自动垃圾回收，没有被释放的对象会被归入1代，同理1代归入2代。
对于因循环引用而无法释放的对象，Python 采用“标记-清除”法。
Python 下造成内存泄漏的原因大概有这几方面：
1. 对象一直被全局变量所引用, 全局变量生命周期长.
2. 垃圾回收机被禁用或者设置成debug状态, 垃圾回收的内存不会被释放.
3. 循环引用过多, gc 无法及时释放
"""
# In[]
import random
L = [1,2,3,5,6,9,8]
random.shuffle(L)
L
"""
1、堆和栈什么区别？
答：管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；
对于堆来说，释放工作由程序员控制，容易产生memory leak。
2、数组和链表什么区别？
答：数组是将元素在内存中连续存放，由于每个元素占用内存相同，
可以通过下标迅速访问数组中任何元素。
链表恰好相反，链表中的元素在内存中不是顺序存储的，而是通过存
在元素中的指针联系到一起。
"""
# In[]
# 反转列表中的字符串
a = [12,3,4,5,6]
a.reverse()
# 现在有以列表 以及列表所对应的索引列表 根据索引列表删除列表中的所对应的元素
# 注意： 如果先删除前面的 则由于python的存储机制 后面的一次向前移动
# 所以需要将索引所对应的列表倒叙进行删除 或者排序在逆序（这样具有普遍性）
L = [1,2,3,4,5,6,7,8,9,10]
c = [2,6,4]
# c.reverse() # 是将列表进行了反转 但是不具有普遍性 该反转直接作用于原始的列表
c.sort(reverse = True) # 将列表进行从大到小排列 确保是从后面删除的数据
for i in c:
L.pop(i)
L
# In[]
# 在numpy数组中获得N个最大值的索引
import numpy as np
a = np.array([1,4,5,6,73,5,7,33,6,0,28,3])
a.argsort() # 返回从小到大排序后得到的顺序在原来的索引
a.argsort()[-3:][::-1]
# 返回最大三个值在初始序列中的索引 从值得大到小依次返回索引
# In[]
"""
22.在Python中命名与文件相关的模块？
Python为库/模块提供了一些函数，使您可以在文件系统上操作文本文件和
二进制文件。使用它们，您可以创建文件，更新其内容，复制和删除文件。
这些库是：os，os.path和shutil。
这里，os和os.path - 模块包括用于访问文件系统的函数
shutil - module使您可以复制和删除文件。
"""
"""
24.解释Python支持的所有文件处理模式？
Python允许您以三种模式之一打开文件。他们是：
通过分别指定标志“r”，“w”，“rw”，“a”，只读模式，只写模式，
读写模式和附加模式。
通过指定选项“t”，可以在上述任何一种模式中打开文本文件
“r”，“w”，“rw”和“a”，以便前面的模式变为“rt”，“wt”，
“rwt”和“at”。二进制文件可以在任何一个中打开上述模式通过指定选项
“b”以及“r”，“w”，“rw”和“a”使得前面的模式变为“rb”，“wb”，
“rwb”，“ab” 。
"""
abc = 1,000,000
a_b_c = 1,000,000
# abc = 1000 2000 3000 错误的形式
# In[]
"""
33.为统计，数值和科学计算命名一些Python模块？
numPy - 此模块提供数组/矩阵类型，它对在数组上进行计算很有用。
scipy - 这个模块提供了进行数值积分，求解微分方程等的方法
.pylab是一个用于生成和保存图的模块
"""
"""
Python面向对象吗？什么是面向对象编程？
是。Python是面向对象的编程语言。OOP是基于类和被称为对象的类的实例的编程范例。OOP的特点是：
封装，数据抽象，继承，多态。
"""
"""
36.什么是多线程？举个例子。
这意味着通过调用多个线程同时运行多个不同的程序。进程中的多个线程使
用主线程引用数据空间，并且它们可以相互通信以更容易地共享信息。
线程是轻量级进程并且具有较少的内存开销。线程可以仅用于快速任务，
如计算结果，也可以在主程序运行时在后台运行其他进程。
"""
# In[]
# 创建集合的正确方法
([[1,2],[3,4]])
([1,2,3,4])
# 条件过滤
list(filter (lambda s:s>5,range(8)))
# In[]
"""
45.解释Python Flask中的数据库连接？
Flask支持数据库驱动的应用程序（RDBS）。这样的系统需要创建一个模式，这需要将shema.sql文件传递给sqlite3命令。因此，您需要安装sqlite3命令才能在Flask中创建或启动数据库。
Flask允许以三种方式请求数据库
before_request（）：在请求之前调用它们并且不传递任何参数
after_request（）：在请求后调用它们并传递将发送到客户端的响应
teardown_request（）：在引发异常时调用它们，并且不保证响应。在构建响应之后调用它们。不允许它们修改请求，并忽略它们的值。
"""
# In[]
"""
48.如何通过Python代码从MySQL数据库中的表中检索数据？说明。
1. 将MySQLdb模块导入为：import MySQLdb
2. 建立与数据库的连接。
3. db = MySQLdb.connect（“host”=“local host”，“database-user”=“user-name”，“password”=“password”，“database-name”=“database”）
4. 在建立的连接上初始化游标变量：c1 = db.cursor（）
5. 通过定义所需的查询字符串来检索信息。s =“选择*来自dept”
6. 使用fetch（）方法获取数据并打印它。data = c1.fetch（s）
7. 关闭数据库连接。close（）
"""
# In[]
"""
argsort : 表示将数据从小到大排序之后 返回排序之前的数据的索引
sort ：表示将数据进行排序 直接作用于原始数据集
sorted ：将数据进行排序不会作用于原始数据 在字典中可以指定是按键值还是按值进行排序
"""
import numpy as np
a = np.array([2,0,4,1,2,4,5])
a.argsort()
list1 = [(‘david‘, 90), (‘mary‘,90), (‘sara‘,80),(‘lily‘,95)]
# 使用字典中的键进行排序 reverse 控制排序
sorted(list1,key = lambda list1: list1[0],reverse = True)
sorted(list1,key = lambda x : x[1])
students = [(‘john‘, ‘A‘, 15), (‘jane‘, ‘B‘, 12), (‘dave‘,‘B‘, 10)]
# 按照年龄将上面的数据进行排序
sorted(students, key = lambda x: x[2] ,reverse = False)
"""
x.isdigit() 表示其中只有字符时为True 否则为False
"""
# ‘asdf234GDSdsf23’这是一个字符串排序，排序规则：小写<大写<奇数<偶数
a = ‘asdf234GDSdsf23‘
# "".join(sorted(a, key = lambda x:(x.islower(),x.isupper(),x.isdigit() and int(x)%2 == 0,x)))
"".join(sorted(a, key = lambda x:(x.isdigit(),x.isupper(),
x.isdigit() and int(x)%2 == 0,x)))
# =============================================================================
# b = []
# c = []
# d = []
# for i in a:
# d.append(i.islower()) # 提取字符串中所有的小写字母
# c.append(i.isdigit()) # 提取出字符串中所有的数字
# b.append(i.isupper()) # 提取出字符串中所有的大写字母
#
# =============================================================================
"".join(sorted(a, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x)))
# =============================================================================
# 解释:
#
# Boolean 的排序会将 False 排在前，True排在后 .
#
# 1.x.isdigit()的作用是把数字放在后边,字母放在前边.
#
# 2.x.isdigit() and int(x) % 2 == 0的作用是保证奇数在前，偶数在后。
#
# 3.x.isupper()的作用是在前面基础上,保证字母小写在前大写在后.
#
# 4.最后的x表示在前面基础上,对所有类别数字或字母排序。
#
# 若不进行第四步，每个内部是未排序的，但是整体顺序是按照要求排序的
#
#
# =============================================================================
list1=[7, -8, 5, 4, 0, -2, -5]
# 要求1.正数在前负数在后 2.整数从小到大 3.负数从大到小
sorted(list1) # 直接排序 得到的结果是 负数排在前面 此时手动加符号按照加入的负号规则进行排序
sorted (list1,key = lambda x:(x<0,abs(x))) # 在取绝对值进行各自内部的排序
a = sorted(list1,key = lambda x:abs(x))
sorted(a,key = lambda x: x<0)
# In[]
s = ‘ABC\-001‘
b = ‘ABC-001‘
str = "Hello,Python";
suffix = "Python";
print (str.endswith(suffix,6));
# =============================================================================
# str.endswith(suffix[, start[, end]]) 用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。
# 可选参数"start"与"end"为检索字符串的开始与结束位置。
# 其中的6表示从第六位开始
# =============================================================================
# expandtabs 表示进行断句遇到 就空格补充后面的数 表示制表符
a = "username pass name"
test = a.expandtabs(20)
test
a = ‘alskdasdaxleadasd‘
a.find(‘axle‘) # 寻找字符串中的， 字符串中的axle的位置
a.replace(‘axle‘,‘mn‘) # 将第一个字符替换为 第二个字符
# In[]
import re
m = ‘asdd3sad44dadasd‘
re.findall(‘d+‘,m) # 匹配出字符串中的数字
s=‘‘‘
ajhfa kasjf owolf english=chinese yes no print
lafl int=456 yes float
int=789 yes
owolf english=france yes aklfl‘‘‘
re.findall(‘english=.* yes‘,s)
# 匹配出1-100的数字
s = ‘asdas100dasdas‘
re.findall(‘d+‘,s)
# 匹配座机号码
s = ‘101-22323223‘
re.findall(‘^d{3,4}-d{7,8}‘,s)
# 查找字符串中有多少个af
s = "asdfjvjadsffvaadfkfasaffdsasdffadsafafsafdadsfaafd"
c = re.findall(‘af‘,s)
len(c)
s = "zhangsan lisi wangwu"
s.split() # 按照空格进行字符串的分割
s = ‘sdd38sd77sd9sf‘
re.sub(r‘d+‘,‘*‘,s)
s = ‘acd123efg‘
re.findall(‘a‘,s)
re.findall(‘d+‘,s)
# In[]
import random
import requests
import re
from bs4 import BeautifulSoup
from pypinyin import pinyin
# 抓取城市数据
headers={‘User-Agent‘:‘Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:58.0) Gecko/20100101 Firefox/58.0‘, ‘Connection‘:‘keep-alive‘}
s = requests.Session()
s.headers.update(headers)
# 百度百科里面的城市
absolute_url = "https://baike.baidu.com/item/%E4%B8%AD%E5%9B%BD%E5%9F%8E%E5%B8%82%E6%96%B0%E5%88%86%E7%BA%A7%E5%90%8D%E5%8D%95/12702007?fr=aladdin"
html = s.get(absolute_url).content
soup = BeautifulSoup(html,"lxml")
citySoup = soup(text=re.compile("市、"))
citys = []
for i in citySoup:
for city in i.split(‘、‘):
citys.append(city.rstrip("自治州").rstrip("市"))
citys = [‘武威市‘,‘长春市‘,‘深圳‘,‘镇江‘,‘西安‘,‘安西‘]
# 运行城市接龙
j = 1
while j <= 6:
city_input = input("请输入一个城市：
")
if city_input == ‘q‘:
break
if city_input in citys:
mcity = []
for c in citys:
if city_input.endswith(c[0]):
mcity.append(c)
# 兼容同音字
elif pinyin(city_input)[-1] == pinyin(c)[0]:
mcity.append(c)
if mcity:
city = random.choice(mcity)
print(city)
else:
print("没有匹配到城市")
else:
print("您输入的不是中国的地级市")
j += 1
# In[]
import pandas as pd
import numpy as np
from scipy import stats
df = pd.read_csv(r"C:UsersAdministratorDesktopLoan Application Data.csv")
df.info()
mu = np.mean(df.fico_range_high) # 均值
sigma = np.std(df.fico_range_high) # 方差
skew = stats.skew(df.fico_range_high) # 偏度
kurtosis = stats.kurtosis(df.fico_range_high) # 峰度
df.fico_range_high.groupby("review_author_id").mad().describe()
import pymysql
# =============================================================================
# import MySQLdb
#
# # 打开数据库连接
# db = MySQLdb.connect("localhost", "testuser", "test123", "TESTDB", charset=‘utf8‘ )
#
# # 使用cursor()方法获取操作游标
# cursor = db.cursor()
#
# # 使用execute方法执行SQL语句
# cursor.execute("SELECT VERSION()")
#
# # 使用 fetchone() 方法获取一条数据
# data = cursor.fetchone()
#
# print "Database version : %s " % data
#
# # 关闭数据库连接
# db.close()
#
# =============================================================================
import pymysql
coon = pymysql.connect(
host = ‘127.0.0.1‘,user = ‘root‘,passwd = ‘1234‘,
db = ‘yinghang‘,charset = ‘utf8‘
#port必须写int类型
#charset必须写utf8，不能写utf-8
)
cur = coon.cursor() #建立游标
cur.execute("select addr_state ,fico_range_high from t3 left join t1 on t3.id4 = t1.id1 group by addr_state") #查询数据
res = cur.fetchall() #获取结果
print(res)
cur.close() #关闭游标
coon.close() #关闭连接
# ---------------------------------------------------------------------------
#如果是插入数据，则要commit一下，把第9行换成以下两行
cur.execute(‘insert into stu(name,sex) VALUE ("pzp","man");‘)
coon.commit()
# In[]
import pandas as pd
import numpy as np
from scipy import stats
df = pd.read_csv(r"C:UsersAdministratorDesktopLoan Application Data.csv")
df1=pd.read_csv(r"C:UsersAdministratorDesktopLoan Application Data2.csv")
df2 = pd.read_csv(r"C:UsersAdministratorDesktopLoan Status Data.csv")
df3 = pd.read_csv(r"C:UsersAdministratorDesktopBorrower Info Data.csv")
df4 = pd.read_csv(r"C:UsersAdministratorDesktopCredit Bureau Data.csv")
df_1 = pd.merge(df,df1,on = ‘id‘,how = ‘left‘)
## df_1: 贷款数据集
# 查看各个属性所含有的数据类型
print(df_1.select_dtypes(‘object‘).apply(pd.Series.nunique, axis = 0))
# 分组统计数据类型
df_1.dtypes.value_counts()
df_1.head()
# 查看数据的具体情况 ----- df_1: 贷款数据集
check_null = df1.isnull().sum().sort_values(ascending=False)/float(len(data))
check_null
print(check_null[check_null > 0.2])
# 查找需要的数据
people = list(data.addr_state.value_counts(dropna = True)) # 查看各州的贷款人数
# 计算各个州的贷款金额.
data = pd.merge(df, df3, on=‘id‘, how=‘left‘)
# 查看数据的缺失值
check_null = data.isnull().sum().sort_values(ascending=False)/float(len(data))
check_null
# print(check_null[check_null > 0.2]) # 查看缺失比例大于20%的属性。
# 分组统计数据类型
data.dtypes.value_counts()
zhou = list(set(data.addr_state))
x = []
for i in zhou:
# print(i)
a = data[data.addr_state == i]
s = sum(a.loan_amnt)
x.append(s)
dic = dict(map(lambda x,y:[x,y],zhou,people))
dic1 = dict(map(lambda x,y:[x,y],zhou,x))
dict = pd.DataFrame.from_dict(dic,orient = ‘index‘,columns = [‘人数‘])
dict = dict.reset_index().rename(columns = {‘index‘:‘洲‘})
dict.head()
dict[‘金额‘] = x
dict # 各个洲的贷款人数和金额数据表
# In[]
# 计算每个洲信用分数的偏度 --
data = pd.merge(df, df3, on=‘id‘, how=‘left‘)
zhou = list(set(data.addr_state)) # 对洲名进行去重
y = []
for i in zhou:
# print(i)
a = data[data.addr_state == i]
skew = stats.skew(a.fico_range_high) # 偏度
y.append(skew)
y
dic2 = list(map(lambda m,n:[m,n],zhou,y))
dic2
df = pd.DataFrame(dic2,columns = (‘洲名‘,‘信用分数偏度系数‘))
df
# 偏度系数大于零表示右偏， 偏度系数小于零表示左偏 ，等于零时正态
# In[]
"""
编译器：使用spyder进行编写
时间： 2019.10.19
项目： 自编函数进行判别ip地址的合法性
"""
# IPv4的ip地址格式：（1~255）.（0~255）.（0~255）.（0~255）
# 利用函数进行检测IP地址的合理性
def is_ipv4(ip: str) -> bool:
"""
检查ip是否合法
:param: ip ip地址
:return: True 合法 False 不合法
"""
if [1] * 4 == [x.isdigit() and 0 <= int(x) <= 255 for x in ip.split(".")]:
return True
else:
return False
def fun1(x):
for i in x.split("."):
if [i.isdigit() and int(i)>=0 and int(i)<= 255] == [1]*4:
return True
else:
return False
fun1("192.168.1.2a0") # False
fun1(‘100.100.100.100‘) # True
fun1("10.10.20.30") # True
fun1("999.10.20.30") # False
fun1("172.29.41") # False
# In[]
"""
编译器： spyder
时间: 2019.10.19
项目：使用数据结构编写函数，找出字符串中第一个出现一次的字符
要求：时间复杂度为O(n)
"""
def fun(s):
s_dic = {} # 设置空字典， 键值存储字符， value 存储对应出现的次数
s_ls = [] # 将字符串中的字符按照顺序存入列表
for i in s :
if i not in s_dic.keys(): # 判断该字符是否出现在字典的key中
s_dic[i] = 1 # 没有出现则值为1
s_ls.append(i)
else:
s_dic[i] += 1
for j in s_ls:
if s_dic[j] == 1:
return j
# 测试部分
fun(‘abcd13faeb‘) # 得到结果： c
fun(‘abcd13faebcd‘) # 得到结果： 1
fun(‘abcd13faebcd13fe‘) # 得到结果： 空，无唯一值出现
# In[]
dic = {‘a‘:1,‘b‘:2,‘c‘:3,‘d‘:4}
dic1 = {‘d‘:2222,‘p‘:111}
dic.update(dic1)
dic.keys()
dic.values()
m = {}
for key,value in zip(‘key_list‘,‘value_list‘):
m[key] = value
m
# In[]
word = [‘apple‘,‘bat‘,‘bar‘,‘atom‘,‘book‘,‘abc‘]
by = {}
# 自编函数进行字典的合并和建立
for i in word:
l = i[0]
if l not in by:
by[l] = [i]
else:
by[l].append(i)
by
# 利用内置的函数进行字典的建立
for i in word:
l = i[0]
by.setdefault(l,[]).append(i)
by
# In[]
# 如果一个字符串可以被哈希化则可以作为字典的健， 否则不可以
hash("ll") # 可以
hash([1,2,3]) # 会因为是列表而不可以，但是元组可以被哈希化，只要其内部的元素被哈希化
hash(tuple([1,2,3]))
3 and 1 and 2
0 and 1 and 2 # 注意0表示假，and一假则全假
# In[]
# 递归函数
def fun(n):
if n>0:
print(‘抱着‘,end = ‘‘)
fun(n-1)
print(‘的我‘,end = ‘‘)
else:
print(‘我的小鲤鱼‘,end = ‘‘)
fun(4)
l = ‘asdasdasda‘
l.upper() # 变小写为大写
l.find(‘s‘) # 按照值寻找索引
s = [‘ s‘,‘sd ‘]
s[0].strip() # strip 去除字符串两端的空白
s = ‘18844501669‘
s.replace(‘4450‘,‘****‘,2)
# 替换字符串，第一个参数表示要替换的字符串，第二个表示替换后的字符串，
# 第三个表示需要替换几次
# In[]
# is 和== 区别
# is表示两个实例之间是不是完全相同，他们是不是同一个对象，占用的内存空间是否相等
# == 表示两个对象的内容是否相等，，至于内存是否相等不重要
# 现有两个元组((‘a‘),(‘b‘)),((‘c‘),(‘d‘))，请使用python中匿名函数生成列表[{‘a‘:‘c‘},{‘b‘:‘d‘}]
t1 = ((‘a‘),(‘b‘))
t2 = ((‘c‘),(‘d‘))
# 使用匿名函数
[*zip(t1,t2)]
list(map(lambda x:{x[0]:x[1]},[*zip(t1,t2)]))
# 列表生成式
[{i[0]:i[1]} for i in [*zip(t1,t2)]]
# In[]
"""
lambda 函数的使用
filter : filter(lambda x: x%3 == 0,[1,2,3]) # 表示过滤列表中的元素
"""
# 排序
sorted([1, 2, 3, 4, 5, 6, 7, 8, 9],key=lambda x: abs(5-x))
def multipliers():
return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
# [6,6,6,6]
print([m(1) for m in multipliers()])
print([lambda x:x*i for i in [1,2,3]])
def multipliers():
return (lambda x:i*x for i in range(4))
print([m(2) for m in multipliers()])
sorted([1, 2, 3, 4, 5, 6, 7, 8, 9],key=lambda x: abs(5-x))
# 排序结果表示 距离数字5的距离远近
# ‘asdf234GDSdsf23’这是一个字符串排序，排序规则：小写<大写<奇数<偶数
a = ‘asdf234GDSdsf23‘
"".join(sorted(a, key = lambda x:(x.isdigit(),x.isupper(),
x.isdigit() and int(x)%2 == 0,x)))
# In[]
# 字典中的fromkeys函数是用来创建字典的
v = dict.fromkeys([‘k1‘, ‘k2‘], [])
v[‘k1‘].append(666) # append函数拼接数据进行是将所有空的都进行填充
print(v)
v[‘k1‘] = 777 # 赋值是仅仅将值赋给对应的键值
print(v)