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}\t{1}\t{2}\n"
         v = template.format(v1,v2,v3)
         s = s + v
         break
print(s)

# expandtabs  意思为将字符串中的TAB符号（\n）转换为空格，默认是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\nGreedyAI") 	#输出一个实际的换行符/回车
print("Hello\tGreedyAI") 	#输出一个实际的 tab 制表符
print("Hello\\nGreedyAI") 	#输出原始的字符串
print(r"Hello\nGreedyAI") 	#输出原始的字符串
print(R"Hello\nGreedyAI") 	#输出原始的字符串

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,‘\n‘,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 表示进行断句遇到\t就空格补充后面的数  \t 表示制表符  
a = "username\tpass\tname"
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 = ‘a\bc\d123efg‘
re.findall(‘a\b‘,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("请输入一个城市：\n")
    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:\Users\Administrator\Desktop\Loan 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:\Users\Administrator\Desktop\Loan Application Data.csv")
df1=pd.read_csv(r"C:\Users\Administrator\Desktop\Loan Application Data2.csv")
df2 = pd.read_csv(r"C:\Users\Administrator\Desktop\Loan Status Data.csv")
df3 = pd.read_csv(r"C:\Users\Administrator\Desktop\Borrower Info Data.csv")
df4 = pd.read_csv(r"C:\Users\Administrator\Desktop\Credit 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)