Python

大数据 云计算
OLTP联机事务 OLAP联机分析
浏览器：前段方向：H5 CSS JS PC
客户端/PC客户端：P樱桃红、java、c++
手机：Android（java、c++） IOS
淘宝、京东、美团、 微信、支付宝：小程序、公众号
数据库：mysql Hbase Oracle
单机游戏：1.有账号
2.账号存在开发商硬盘上（物理存储）

针对内存操作的语言：java、Python、go语言、C语言
BS：针对浏览器开发
CS：针对客户端开发

1.了解（特点、应用场景、历史）
2.目的（完成小项目）
3.安装环境
4.基本语法
5.数据存储 利用逻辑语言来模拟现实（分子、原子）
6.面向对象
7.高级特性
8.框架
9.项目

new file后先用Ctrl+S保存 以.py结尾
Ctrl+B 执行
定义、if、while语句后面加：
input默认字符串类型
def 定义函数
驼峰命名法

#单行注释#

‘’’
多行
注释
‘’’

print (“hello world”)

首行缩进：语法结构——行缩进：Tab键
if 20>10:
print(“这是对的”)
print(“aa”)
else:
print(“这是不对的”)

语法：标识符 = 数据
定义标识符注意：
1.标识符的第一个字符必须以字母或下划线开头
2.其他部分只能是字母、数字、下划线、总之不能是特殊符号字符
3.标识符不能是关键字 eg.if 定义的标识符要尽量有意义

（1）输出
格式化输出：对不同数据类型的数据进行整合再输出

age = 20
print(age)

age=13
#print(“我今年age岁”)
print(“我今年%d岁”%age)
a.变量名称必须相同
b.数据类型必须匹配
‘’’
%d代表整数 %age代表上面的age 若age是整数 那么就赋值给%d 若age为小数 那么%d会取整输出
变量的取值在括号外面
看数据类型eg.13与%d部分是否匹配 看%age部分与age部分是否匹配
字符串------%s 整数------%d \n-----换行
‘’’

（2）输入
a = input(str) ----str在输入时，终端现实的内容
print(a) ----a 在终端输入的内容

a = input(“今天上课去不去”)
print(a+“不去”)
打出今天上课去不去 回车就会出现今天上课去不去 不去

Number（int、float、bool、complex)

int—整型 float-----小数 bool----True/False True为1 False为0 complex-----复数 eg.(1+2j)

a = 100000
b = 3.14
c = True
d = j # j前面带有数字，表示复数#
d = 1j d2 即d的平方 即(-1+0j) d2 即d的平方 **几就是几次方

type——查数据类型
a1 = type(d)
print (a1)

字符串
名词解释：由多个字符拼接成一个整体的数据结构–串
注意事项：特殊字符(#$%&)在字符串中有特殊意义的需要对其进行转换"//n" r"/n"
（1）字符串创建：标识符 = ‘abc’ “asd”
（2）字符串中字符的获取
s = “abcdefg”
s[0] s[1] s[2]…
方法：获取字符串的长度–b = len(s) b就是长度
（3）切片
语法：s[start?step] [)
a、s[:10] # 从0位置截取10
b、s[2:] # 从2位置截取到len(s)+1
c、s[:] # 从头到尾
b、s[::2] # aceg
d、s[::-1] # gfed…
e、s[::-2] # gec…
s = ‘10’
s1 = “3.14”
print (s+’ 1’) #会得到101#

s=‘abc’
print (s[0/1/2]) 会得到a/b/c

爬虫支持切片
a = ‘企业购 ’
print (a[6]) 得到 企
print (a[6：9]) 得到 企业购 # 切片切成左开右闭区间 [ 不包括右边 a?️c第三位是跳转步长
s = ’ abcde’
print(a[1:5:2]) （中间隔得比第三位少一） 跳一位得到ace 1:5:3 跳两位 ad 1: 得到bcde
:3 得到abc ::-1 得到edcba 倒序 负数时 前面的靠后 中间的靠前 -1：-4：-1

len--------字符串长度

#序列——数据集合
#列表、数组、集合
list = [“星期一”，“星期二”] 对数据集的封装

CRUD——C(create)R(read)U(update)D（delete） 增查改删

C—标识符 = [‘ab’,‘bc’,‘cd’] 创建

l = [1,5,2,7,4,6]
print (type(l)) 得到list类型

R 获取数据

print（l[ len(l)-1]） 得到6
print(l[3]) 得到7

U 改数据

l[ len(l)-1] = 20
print(l) 得到[1,5,2,7,4,20]

D 删除数据

del l[ len(l)-1]
print(l) 得到[1,5,2,7,4]

序列–列表
CRUD(C-create、R-read、U-update、D-delete)
名词解释：列表就是一系列数据的集合，这些数据可以是相同类型，也可以是不同类型
例子：list = [1,2,3,4,5,3.1,3.2,“abc”]
C: list = [data,data…]
R: list[0] list[1] list[2]…
U: list[0] = “mn”
D: del list[1]

list = [1,5,2,8,5]

print(len(list))

a = list.sort()
print(list)

a、列表支持len()
b、列表支持切片
c、排序list.sort()
d、矩阵

算法

排序（时间复杂度O（1）O（n）O(n^2)O(nlogn)…）

针对列表的一系列数据应用

list =[1,3,4,5,67,2,2]
print (li) 得到[1,3,4,5,67,2,2,]
list.sort() （ 排序 ）
print(list) 得到[1,2,2,3,4,5,67]

利用列表完成创建矩阵

‘’’
1 2 3
4 5 6
7 8 9
‘’’
‘’’
l1 = [1,2,3]
l2 = [4,5,6]
l3 = [7,8,9]
l = [l1,l2,l3]

矩阵值获取方法

a = l[1]
b = a[1]
print(b)
print(l[1][1])

l1 = [1]
l2 = [2,6,3,4,5]
l3 = [4,5,6]

l = [l1,l2,l3]

练习：
[1,2,3]
[4,5,6]
[7,8,9]
求：矩阵对角线的和

l1 = [1,2,3]
l2 = [4,5,6]
l3 = [7,8,9]
l = [l1,l2,l3]
a = l[0][0]
b = l[1][1]
c = l[2][2]
print(a+b+c)

• 加 两个对象相加 a + b 输出结果 30

• 减 得到负数或是一个数减去另一个数 a - b 输出结果 -10

• 乘 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
  / 除 x除以y b / a 输出结果 2
  // 取整除 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
  % 求模，取余 返回除法的余数 b % a 输出结果 0
  ** 幂 返回x的y次幂 a**b 为10的20次方， 输出结果 100000000000000000000

a = 9
b = 2
print(a**3)
a = 3
print(a)
b = a
print(a)
print(b)

运算符 描述 实例
+= 加法赋值运算符 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

a = 1
b = 2
a+=b # a = a + b

a + b = 3

a = 3

print(a)
print(b)
‘’’
a = 10
print(type(a))
b = str(a)
print(type(b))

只有相同数据类型才能进行运算
age = ‘11’
a = 5
print(int(age) + a)
print(“今年我”+str(age)+“岁”)

if判断主要是用来做逻辑处理
根据具体的条件来确定语句是否执行

语法：
if condition:
pass
pass
…
elif condition:
pass
…
elif condition:
pass
…
…
else:
pass
pass

‘’’

是否有钱，是否可以约会，是否可以卖花

‘’’

‘’’
name = ‘zhangsan’
salary = 150 # 花150
work = 6
#1、判断是否有时间
#2、钱是否够了
if work == 6:
print(“可以出去”)
if salary >= 150:
print(“买粟花”)
print(“在一起了”)
elif salary < 0
print(“没钱，还有贷款呢”)
print(“永远再见”)
else:
print(“空手去吧”)
print(“再见”)

elif work == 7:
print(“也可以出去”)
if salary >= 150:
print(“买粟花”)
else:
print(“空手去吧”)
print(“再见”)
else:
print(“不可以出去”)
print(“永远再见”)

循环(遍历)目的：可以按照一定的规则对序列、集合、数据进行遍历操作
1、while
语法：
while condition:
a pass
…
else: # 可以没有的
b pass # 可以没有的
… # 可以没有的
如果条件成立(True)a中的代码会循环不断的执行,直到条件为False时，循环停止。执行else中的语句
注意：else和if判断一样，可以省略
break:结束循环
continue:结束本次循环，进行下次循环

2、for循环：主要针对序列进行遍历
语法：
for 标识符（）变量 in 序列：
pass

序列：一系列数据的集合–列表、字符串、dict、set、元组

list=[1.5.6.2.3]——遍历序列中的数据
1、
for L in list:
print(L)
2、
list=[1，5，6，2，3]
for L in range(1,101)
print(L)
(遍历序列中的数据，生成1到100序列，用for来完成1到100的求和)

序列类型：
（1）list-----列表
（2）Tuple-----元组
（3）dict-----字典
（4）set-----集合
（5）string----字符串
（6）number

一、元组
创建：
t=(1，4，2，3，5)
读取：
print（t[1]）——结果为4
（元组支持切片，len）
for t1 in t:
print(t1)
(结果为t中数据的东西)
更新：不支持更新
删除：不支持删除
只读模式
元组和列表的区别：列表是可以更改的而元组是只读的，一旦创建，就不能对内部值进行更新和删除

二、字典
创建：
d=(“name”,"zhangsan’,“age”:18,“sex”:男)
item={“item_name”:“phone”,“price”:5000,“detail”:这是一个手机}
l=[d,item]
读取：
print(zhangsan[“age”])——结果为18
更新：
zhangsan[“age”]=19
print(zhangsan)
删除：
del zhangsan[“age”]
print(zhangsan)
1.获取字典中所有的keys
print(zhangsan,keys())
2.获取字典中所有的value
print(zhangsan.values())
3.遍历字典：
for a in zhangsan:
print(a)——取出字典中所有的keys
for a in zhangsan.keys():
print(a)
4.for a in zhangsan:
print(zhangsan[a])——取出字典中所有的values
for a in zhangsan.values():
print(a)

函数
语法：
def 函数名（变量）：
pass
return 一个或多个变量
a=10
b=20
print(a+b)
a=40
b=50
print(a+b)

def 方法名/标识符（标识符-变量，标识符-变量，标识符-变量…）：
pass -----方法体
def jiafa(a,b):
print(a+b)
a=10
b=20
jiafa(a+b)/jiafa(10,20)

方法：
1.无参无返回值
def shuangwu():
print("--------info------")
shuangwu()
2.有参无返回值
def jiafa(a,b):
print(a+b)
a=10
b=20
jiafa(a,b)/jiafa(10,20)
3.无参有返回值
a=10
b=20
def youreturn():
c=a+b
return c
a=youreturn()
print(a)
4.有参有返回值
求一个圆的面积
import math——代表为π
p=math.pi
def mianji(r）:
m=pr**2
return m
r=1
m=mianji®
print（m)
求长方体的体积
c=10
w=10
h=5
def tiji(a,b,c):
return abc
t=tiji(c,w,h)
print(t)
求长方体的体积同时获得表面积：
c=10
w=10
h=5
def tiji(a,b,c):
return abc
def biaomianji(a,b,c):
return cw*2+
b=biaomianji(c,w,h)
t=tiji(c,w,h)
print(t)
print(b)

多返回值参数：
表面积和体积同时要求出
def abc(a,b,c):
t=abc
b=cw2+
return t,b
1.a=abc(c,w,h)------------一起接受
print(a)
2.a,b=abc(c,w,h)----------分别接受
print(a)
print(b)
3.a=abc(c,w,h)
c,d=a--------a是元组，可以拆分
print©
print(d)
4.
c=10
w=10
h=5
def tiji(a,b,c):
m=biaomianji(a,b,c)
return abc,m
def biaomianji(a,b,c):
return cw2+
t=tiji(c,w,h)
print(t)

‘’’
1、设置一个变量为a = 10，当a < 20时
执行循环并且a不断+1,打印’成立’，当a>=15,不打印’成立’,打印a值
2、while循环完成1-100的求和

a = 10
while a <= 20:
a += 1
if a >= 15:
print(a)
continue
print(“成立”)
else:
print(“循环结束”)

分析
1-100
每一个分别相加1+2=3 3+3=6 6+4=10 10+7=17 …
a = 0
sum = 0
while a <= 100:
sum+=a
a+=1
print(sum)

九九乘法表
a = 0
while a<0:
b = 0
while b<=a:
print(str(b+1)+’’+str(a+1)+’=’+str((b+1)(a+1)),end=’ ')
b+=1
a+=1
print()

面向对象：面向对象是对现实事物的抽象，用计算机语言来模拟程序中所需要描述的事物
人-买-东西（电商平台功能） -利用程序语言
人-真实存在的事物
买-动作
东西-真实存在的事物

#字典
person = {“name”:“zhangsan”,“age”:18,“money”:200,“count”:1}

item = {“item_name”:“phone”,“system”:“IOS”,“sell”:150"count":5}

#人买1部手机
def buy(person ,item):
#是否需要手机：一个人的手机建议不多于2个
if person[“count”]>2
print(“不建议购买”)
return
if person[“money”] <= item[“sell”]:

print(“钱不够了，去挣钱吧”)
return
#person[“money”] = person[“money”] - item[“sell”]
person[“money”] -= item[“sell”]
person[“coune”] += 1
item[“count”]-= 12
buy(person,item)
print(person)
print(item)

#人买n部手机
def buy(person ,item,n): #若n=1时就不用写带n的部分
#是否需要手机：一个人的手机建议不多于2个
if person[“count”]>2 or (person[“count”]+n) > 2:
print(“不建议购买”)
return
if person[“money”] <= item[“sell”]*n:
c = person[“money”]//item[“sell”]
print(“钱不够了，只能买%d部手机，去挣钱吧”%c)
return
#person[“money”] = person[“money”] - item[“sell”]
person[“money”] -= item[“sell”]*n
person[“coune”] += n
item[“count”] -= n
m=int(input())
buy(person,item,m)
print(person)
print(item)

person = {“name”:“zhagnsan”,“age”:18,“money”:150,“count”:1}
item = {“item_name”:“phone”,“system”:“IOS”,“sell”:150,“count”:5}
person[“money”] = int(input(“你有多少钱？”))
n = int(input(“想购买几台手机”))
def buy(person,item,n):
if person[“count”]>2 :
print (“手机数量太多了，不建议购买”)
return
if person[“money”]>=nitem[“sell”]:
can = person[“money”]//item[“sell”]
if (person[“count”]+can)>2:
x = input(“您是否独自购买，还是集体购买:”)
if x==“独自购买”:
print(“手机数量太多了，不建议购买。”)
return
elif x ==“集体购买”:
print(“欢迎光临”)
else:
print(“输入有误”)
if person[“money”]<=nitem[“sell”]:
can = person[“money”]//item[“sell”]
print (“钱不够了，你只能买%d部手机，去挣钱吧！”%can)
return

person["money"] -=item["sell"]*n
person["count"] += n
item["count"]-= n
if item["count"]<0:
    print("很抱歉，库存不足！")
    return

buy(person,item,n)
print(person)
print(item)

逻辑运算符(bool)
a = 10, b = 20
运算符 逻辑表达式 描述
and x and y 布尔"与" 如果x为 False，x and y 返回False，否则它返回y的计算值
实例 (a and b) 返回 20

or x or y 布尔"或" 如果x是 True，它返回x的值，否则它返回y的计算值
实例 (a or b) 返回 10

not not x 布尔"非" 如果x为 True，返回False 。如果x为False，它返回True

类
person（人）------很多人 给对象设置属性赋值
相当于一个模板或设计图，可以通过类来设计实体
基本数据类型：程序语言提供的
引用数据类型
类基本语法
class Person：
#类中方法
#每当创建实体时，初始化方法执行一次

p = Person() #先创建类 然后让人=类 要在定义的下面使用这一语句
print§
print(type§)
a = 10
print(type(a))

def init(self,name,age,money,count): #初始化方法—主要针对类的属性进行定义
#def__init__：初始化实例的值.这些值一般要供其他方法调用
self.name =name #self代表着当前对象
self.age = age
self.money = money
self.count = count
print(“初始化—”) #打印初始化代表类已经创建完成
def test(self):
print("------------test-------------")

#创建人这个实体
zhangsan = Person(“zhangsan”,18,150,2) #创建对象
print(zhangsan.name)
print(zhangsan.age)
print(zhangsan.money)
print(zhangsan.count)
zhangsan.test()
lisi = Person(“lisi”,28,350,4) #创建lisi对象 执行的话会出现两个初始化
print(lisi.name)
print(lisi.age)
print(lisi.money)
print(lisi.count)
lisi.test()

#打印方法
def pri(self):
print(self.name)
print(self.age)
print(self.money)
print(self.count)
zhangsan = Person(“zhangsan”,18,150,2)
zhangsan.pri()
lisi = Person(“lisi”,28,350,4)
lisi.pri()

用户

class Person:
# 类中方法
# 每当创建实体时，初始化方法执行一次
def init(self,name,age,money,count): # 初始化方法–主要针对类的属性进行定义
self.name = name # self代表当前对象
self.age = age
self.money = money
self.count = count
# print(“初始化—”)
def test(self):
print("------test-----")
# 打印方法
def pri(self):
print(“用户名：”+self.name + " 年龄："+ str(self.age) + " 存款："+str(self.money)+" 手机数:"+str(self.count))
# 买一部手机
def buyPhone(self,phone):
if self.count > 6:
print(“手机够多了，别买了”)
return
if self.money < phone.sell:
print(“你买不起”)
return

	self.money -= phone.sell
	self.count += 1
	phone.count -= 1
	print("购买成功")
	# phone.pri()

商品

class Item:
def init(self,item_name,system,sell,count):
self.item_name = item_name
self.system = system
self.sell = sell
self.count = count
def pri(self):
print(“手机名称：”+self.item_name + " 手机系统："+ str(self.system) + " 手机卖价："+str(self.sell)+" 手机库存:"+str(self.count))

创建人这个实体

zhangsan = Person(“zhangsan”,18,7500,5) # 创建对象

zhangsan.pri()

phone = Item(“华为-p30”,“android”,6550,20)

phone.pri()

zhangsan.buyPhone(phone)
zhangsan.pri()
phone.pri()

class Person:
#类属性
1.所有对象都可以共享
2.直接可以通过类调用
3.类属性主要定义的是针对类所创造的所有对象的共性特征
4.self可以直接调用类属性
5.在类的方法中也可以通过类名直接调用类属性
#类方法
1.类上加上装饰器@classmethod
2.修改方法中的变量cls
3.cls实际就是当前类，Person（类名）
静态方法
方法上加上装饰器@staticmethod
类方法与静态方法区别：
类方法中包含cls变量，而静态方法中不包含cls变量

	#cry = "wawawa"

#类方法
@classmethod
def cry(cls):
print(cls.abc)
priint(“wawawa”)
#静态方法
@staticmethod
def stat():
print("--------这是静态方法--------")
def init(self):
self.name = “zhangsan” #实例属性
print("-----初始化---------")
def test(self):
print(self.cry)
print("-------test-------")
p = Person()
p1 = Person()
p2 = Person()
print（p.test）
print(p.cry)
Person.cry
p.cry

继承
object：是所有类的的父类
作用：子类对象可以使用父类方法以及属性
1、父类不可以调用子类的方法
2、多层继承，子类可以调用多级父类的方法
3、多继承：一个类可以继承多个类的方法和属性
当多个父类中有相同的方法时，那个子类优先调用写在前面的类的方法

class Person(object):

def eat(self):
print(“吃饭”)

class User(Object):
def buy(self):
print("----会购物—")
class Student(User):
def study(self):
print("—学习—")
class Boy（Person,User）:
pass
class Girl（Person,User）:
pass

b = Boy()
b.eat()
b.buy()
g = Girl()

P = Person()
S = Student()
U = User()
U.buy()
U.eat()

#数据分析工具
numpy
pandas

#前端
html js css
vue react velocity anglear

#java
js ajax
javaWeb(servlet filter listener)
Spring SpringMvc mybatis
SpringBoot SpringCloud
mysql redis Nginx MQ

#bigData
linux shell
Hadoop flume kafka
Hbase Hive EleasticSearch
Spark Flink

#云计算
网络协议
linux
docker openStack

#测试
功能测试：lox(5000-6000)
性能测试：python java
jmeter runloader
自动化测试：python java js

#UI
html css js
PS

#产品经理
uml ross

#数据分析
R numpy pandas D3 Echarts spark mapReduce (Hadoop)

#人工智能
数学（概率论、线性代数、）

牛客网：针对应届生求职 有题库 真题 在线测试 面试汇总 可以针对公司选择 有很多大企业 针对大公司的校招模拟笔试

阿里云计算课程学习 阿里云大学
阿里云认证…高级工程师证…