大数据--python学习

1.列表和元组之间的区别是？

list是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。一旦你创建了一个列表，你就可以添加，删除，或者是搜索列表中的项目。由于可以增加或删除项目，所以列表是可变的数据类型，即这种类型是可以被改变的，并且列表是可以嵌套的。

元组和列表十分相似，不过元组是不可变的。即你不能修改元组。元组通过圆括号中用逗号分隔的项目定义。元组通常用在使语句或用户定义的函数能够安全的采用一组值的时候，即被使用的元组的值不会改变。元组可以嵌套。

2.解释一下Python中的继承

当一个类继承另一个类，它就被称为一个子类/派生类，继承父类/基类/超类。它会继承/获取所有类成员（属性和方法）

继承能让我们重新使用代码，也能更容易的创建和维护应用

单继承：一个类继承单个基类

多继承:一个类继承多个基类

多级继承：一个类继承自单个基类，后者继承自另一个基类

分层继承：多个类继承自单个基类

混合继承：两种或多种类型继承的混合

3.Python中的字典是什么？

字典是Python语言中唯一的映射类型。

映射类型对象里哈希值（键，key）和指向的对象（值，value）是一对多的的关系，通常被认为是可变的哈希表。

字典对象是可变的，它是一个容器类型，能存储任意个数的Python对象，其中也可包括其他容器类型。

4.请解释使用*args和kwargs的含义**

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即g形如key=value的参数， kwargs为字典。

5.请写一个Python逻辑，计算一个文件中的大写字母数量

with open('test.txt') as test:
    count = 0
    for i in test.read():
        if i.isupper():
            count += 1
print(count)

6.什么是负索引？

7.Python区分大小写吗？

标识符区分大小写

8.怎么移除一个字符串中的前导空格？

用方法 Istrip() 可以将它从字符串中移除。

9.怎样将字符串转换为小写？

lower()方法

10.Python中的pass语句是什么？

用python写代码时，有时可能还没想好函数怎么写，只写了函数声明，但为了保证语法正确，必须输入一些东西，这种情况下，可以使用pass语句

**11.解释一下Python中的//，%和 ****运算符。

//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余（取模）	返回除法的余数 b % a 输出结果 0
**	幂	返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000

12.在Python中有多少种运算符？解释一下算数运算符。

在python中，我们有7种运算符：算术运算符、关系运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符

我们有7个算术运算符，能让我们对数值进行算术计算

1、加号(+)，将两个值相加

2、减号(-)，将第一个值减去第二个值

3、乘号(*),将两个值相乘

4、除号(/),用第二个值除以第一个值

13.解释一下Python中的关系运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3则（a == b) 为 true.
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3则(a != b) 为 true.
<=	3、小于等于号，如果左边的值小于或等于右边的值，则返回True	如a=1,b=3则(a <= b) 为 true。
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a > b) 为 true.
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3则(a < b) 为 false.
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3则(a >= b) 为 true.

14.解释一下Python中的赋值运算符

运算符	描述	实例
=	赋值运算符	把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7

+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

15.解释一下Python中的逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

16.解释一下Python中的成员运算符

通过成员运算符‘in’ 和 ‘not in’，我们可以确认一个值是否是另一个值的成员

print('me' in 'disappointment')#True
print('us' in 'disappointment')#False

17.讲讲Python中的位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

按位与 ( bitwise and of x and y )

& 举例： 5&3 = 1 解释： 101 11 相同位仅为个位1 ，故结果为 1

按位或 ( bitwise or of x and y )

| 举例： 5|3 = 7 解释： 101 11 出现1的位是 1 1 1，故结果为 111

按位异或 ( bitwise exclusive or of x and y )

^ 举例： 5^3 = 6 解释： 101 11 对位相加(不进位)是 1 1 0，故结果为 110

按位反转 (the bits of x inverted )

举例： ~5 = -6 解释： 将二进制数+1之后乘以-1，即~x = -(x+1)，-(101 + 1) = -110

按位反转仅能用在数字前面。所以写成 3+~5 可以得到结果-3，写成3~5就出错了

按位左移 （ x shifted left by n bits ）

<< 举例: 5<<2 = 20 解释：101 向左移动2位得到 10100 ，即右面多出2位用0补

按位右移 （ x shifted right by n bits ）

举例： 5>>2 = 1 解释：101 向右移动2位得到 1，即去掉右面的2位

18.怎样获取字典中所有键的列表？

values 返回一个包含字典所有value的列表

19.怎样声明多个变量并赋值？

a, b, c = 1, 2, “john”

20.为何不建议以下划线作为标识符的开头

因为python没有私有变量的概念，所以约定俗称以下划线为开头来声明一个变量为私有，所以如果你不想让变量私有，就不要使用下划线开头

21.一行代码实现1到100的求和

print(sum(range(0,101)))

22.详细描述单例模式的实现

保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

实例化一个单例

`class` `Singleton(``object``):``  ``_instance ``=` `None` `  ``def` `__new__(``cls``, ``*``args):``    ``if` `not` `isinstance``(``cls``._instance, ``cls``):``      ``cls``._instance ``=` `super``(Singleton, ``cls``).__new__(``cls``, ``*``args)``    ``return` `cls``._instance`

23.详细描述工厂模式的实现​

class Factory:

	def createFruit(self,fruit):

		if fruit=="apple":

			return Apple()

		elif fruit=="banana":

				return Banana()

class Fruit:

	def __str__(self):

		return "fruit"

class  Apple(Fruit):

	def __str__(self):

		return "apple"

class Banana(Fruit):

	def __str__(self):

		return "banana"

if __name__=="__main__":

			factory=Factory()

			print factory.createFruit("apple")

			print factory.createFruit("banana")

			

​

24.python操作数据库的步骤

1、执行SQL

import pymysql
# 创建连接
conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='123', db='t1')
# 创建游标
cursor = conn.cursor()
# 执行SQL，并返回收影响行数
effect_row = cursor.execute("update hosts set host = '1.1.1.2'")
# 执行SQL，并返回受影响行数
#effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))
# 执行SQL，并返回受影响行数
#effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
# 提交，不然无法保存新建或者修改的数据
conn.commit()
# 关闭游标
cursor.close()
# 关闭连接
conn.close()

2、获取新创建数据自增ID

import pymysql
conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
conn.commit()
cursor.close()
conn.close()
# 获取最新自增ID
new_id = cursor.lastrowid

3、获取查询数据

import pymysql
conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.execute("select * from hosts")
# 获取第一行数据
row_1 = cursor.fetchone()
# 获取前n行数据
# row_2 = cursor.fetchmany(3)
# 获取所有数据
# row_3 = cursor.fetchall()
conn.commit()
cursor.close()
conn.close()

25.NumPy中几个熟悉的函数的使用

基础函数

import numpy as np

print(np.abs(-1))  # 绝对值
print(np.sqrt(9))  # 平方根
print(np.square(3))  # 平方np ** 2
print(np.exp(2))  # e^x
print(np.log2(2))  # log2^2 底数为2的对数
print(np.log10(10))  # log10^10 底数为10的对数
print(np.log(np.e))  # loge^e 自然对数
print(np.sign(-165), ":", np.sign(321), ":", np.sign(0))  # 返回各元素的正负号 1正 0零 -1负
print(np.ceil(3.65))  # 大于等于该值的最小整数
print(np.ceil(-3.65))
print(np.floor(3.65))  # 小于等于该值的最小整数
print(np.floor(-3.65))

array = np.random.randint(1, 10, 9).reshape(3, 3)
print(array.sum())  # 所有元素的和 零长度的数组的sum为0
print(array.sum(0))  # 每一列的求和
print(array.sum(1))  # 每一行的求和

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(np.mean(list))  # 算术平均数 (1+2+3+...+10)/10
# list = []
# print(np.mean(list))# NaN     零长度的数组的mean为NaN
print(np.max(list))
print(np.min(list))
print(np.argmax(list))  # 数组最大值的索引
print(np.argmin(list))

print(np.cumsum(list))  # 所有元素的累计和
print(np.cumprod(list))  # 所有元素的累计积

print("np.modf(100.12) : ", np.modf(100.12))  # 将数组中的小数部分和整数部分以两个独立数组的形式返回
print("np.modf(100.72) : ", np.modf(100.72))
print("np.modf(math.pi) : ", np.modf(np.pi))

list2 = [112, 113.65, 125, 365.56, 788.98]
print("np.modf(list2) : ", np.modf(
    list2))  # np.modf(list2) :  (array([0.  , 0.65, 0.  , 0.56, 0.98]), array([112., 113., 125., 365., 788.]))

# subtract:从第一个数组中减去第二个数组中的元素
list3 = [3, 4, 5]
list4 = [1, 1, 1]
print(np.subtract(list3, list4))
# add:将数组中对应的元素相加
array1 = np.random.randint(1, 10, 9).reshape(3, 3)
array2 = np.random.randint(1, 10, 9).reshape(3, 3)
print(array1)
print(array2)
print(np.add(array1, array2))
# multiply:数组元素相乘(对应元素相乘) 区别于矩阵乘法
print(np.multiply(array1, array2))
# diag以一维数组的形式返回方阵的对角线元素
print(np.diag(array1))
print(np.diag(array2))
# dot矩阵乘法
print(np.dot(array1, array2))
# trace计算对角线元素的和
print(np.trace(array1))
print(np.trace(array2))
# det 计算矩阵行列式
print(np.linalg.det(array1))
print(np.linalg.det(array2))
# eig 计算方阵的特征值和特征向量
a2 = np.array([[1, 2, 3], [2, 3, 4]])  # 建立一个二维数组
b2 = np.array([[1, 2, 3], [2, 3, 4]], dtype=int)  # 可以输出指定数据类型
# print(np.linalg.eig(a2))  # 返回矩阵a2的特征值与特征向量

运行结果

1
3.0
9
7.38905609893065
1.0
1.0
1.0
-1 : 1 : 0
4.0
-3.0
3.0
-4.0
37
[12 12 13][ 8 11 18]
5.5
10
1
9
0
[ 1  3  6 10 15 21 28 36 45 55][ 1 2 6 24 120 720 5040 40320 362880 3628800]
np.modf(100.12) :  (0.12000000000000455, 100.0)
np.modf(100.72) :  (0.7199999999999989, 100.0)
np.modf(math.pi) :  (0.14159265358979312, 3.0)
np.modf(list2) :  (array([0.  , 0.65, 0.  , 0.56, 0.98]), array([112., 113., 125., 365., 788.]))
[2 3 4][[6 2 1]
 [3 5 5][4 7 9]]
[[6 3 6]
 [6 3 5]
 [7 1 3]][[12 5 7]
 [ 9  8 10][11 8 12]]
[[36  6  6]
 [18 15 25]
 [28  7 27]][6 5 9]
[6 3 3][[ 55 25 49]
 [ 83  29  58][129 42 86]]
20
12
47.000000000000014
-15.0

矩阵相关操作和切片

# 矩阵的逆
array = np.random.randint(1, 10, 9).reshape(3, 3) # n*n的矩阵一定会有逆矩阵
# print(array)
# array2 = np.linalg.inv(array)# 生成矩阵的逆
# print(array2)
# 矩阵的乘法
# array3 = np.dot(array2, array)# 矩阵*逆矩阵=单位矩阵
# print(array3)# 单位矩阵:对角线元素为1

# 矩阵转置
# print(array.T)

# 基本运算
# print(array.sum())  # 所有元素的和
# print(array.sum(0))  # 每一列的求和
# print(array.sum(1))  # 每一行的求和

# 切片
# array = np.random.randint(1, 10, 20).reshape(4, 5)
# # array2 = np.ones(20).reshape(4, 5)# 加减时  reshape中数字与array中一样
# array2 = np.ones(20).reshape(5, 4)# 矩阵乘法a*b时,要保证a的列数等于b的行数    a:m*p  b:p*n


# 切片
array = np.random.randint(1, 10, 16).reshape(4, 4)
print(array)
print("-------分割线---------")
# 取出第一行的所有值
print(array[0]) # 相当于 array[0,:]
print("-------分割线---------")
# 取第一列
print(array[:, 0])
print("-------分割线---------")
# 取第一行和第三行
print(array[0::2, :])
print("-------分割线---------")
# 取第二列和第四列
print(array[::, 1::2])
print("-------分割线---------")
# 取第一行和第三行的第二列和第四列
print(array[0::2, 1::2])
print("-------分割线---------")
# 遍历多维数组
for i in range(0, array.shape[0]):
    for j in range(0, array.shape[1]):
        print(array[i][j], end="\t")
    print()
    

array = np.random.randint(1, 10, 9).reshape(3, 3)
print(array)
print(np.where(array > 5, array, 0))# 将大于5的值留下来,小于5的用0代替
print(array[2][2])