python

第一节课
1.客户端开发需要python，Java：浏览器开发需要H5，PC客户端
2.手机客户端:安卓（Java语言，C语言），iOS，微信（公众号，小程序用到H5语言），支付宝（小程序）
3.数据库是物理概念，是真实存在的，在硬盘上（好处：他可以永久保存；坏处：比较慢——解决方案拥有一个内存——服务器来交互客户端与数据库）。
4.内存操作语言：Java，python，c#
5.BS：针对浏览器开发
CS：针对客户端开发
6.OLTP：联机事务与
OLAP：联机分析；大数据，云计算数据保存在数仓，从这里调取信息，进行分析。

1.了解（特点，应用场景，历史）
2.目的（完成小项目）
3.安装环境
4.基本语法（逻辑与动作）
5.数据存储（分子，原子——二进制）
6.面向对象
7.高级特性
8.框架
9.项目
利用逻辑语言模拟现实（分子，原子），逻辑，动作
当a已经有数据类型时候直接用括号就行

当a没有数据类型时：

一，注释作用：对代码进行解释和说明，不参与代码的执行
1.# +空格为单行注释
2.‘’‘
’‘’为多行注释，必须成对出现
（注释作用对代码片段进行说明）
二，语法结构：首行缩进——tab键（作用：区分方法体
if condition(条件）:
pass(方法体）
pass(方法体）
if 20>10:
print("这是对的“）
else
print("这是不对的“）
（前方空格均为tab键）
if 20>10:
print("这是对的“）
print(“aa”)
格式是对的。
if 20>10:
print("这是对的“）
print(“aa”)
else
print("这是不对的“）
格式是对的。
三，1.‘ ‘ 2. “ “代表字符串 且 “”“代表段落。
四，变量的定义：
语法结构：标识符 = 数据（数据类型）
age=20
print（age）
（注：1.第一个字符必须以字母下划线开头；
2.命名中带有中文也可，中文最后也以字母形式存在，不能为关键字，不可以添加特殊数字符。）
在控制台输出：print（“”）
把对应的字符串与变量整合：
格式化输出语法:
age = 10
print（“我今年%d岁”%age)
（ %d代表整数，必须保证变量名一致，数据类型一致，如果age为小数，但是因为%d的后果，结果仍为整数。）
五，运算符：
(1)数据类型：
1.Number（int整型，float小数浮点型，bool——true/false，complex复数）
bool：c=true或者false——true–1/false–0
print©
complex：d=1+2j——————j前面有数字，代表复数
print=(d)
2.string——字符串
3.list——列表
4.tuple——元组
5.dict——字典
6.set——集合
(平方：**2)
(2)方法：type（数据）——查看数据类型
a1=type(a)
print(a1)
六，输入和输出：
1.输出：print(data)——格式化输出：对不同数据类型的数据进行整合在输出
age=10
print（“今年我%d”%age）
注意事项：1.变量名称必须相同
2.数据类型必须匹配
2.输入
方法：a=input（str） ——str：在输入时，终端实现的内容
print（ a) ——a:在终端时输入的内容

换行输出：1.print(“题西林壁\n苏轼“）——显示结果为题西林壁
苏轼
2.print(“题西林壁\n苏轼“）或print(r"题西林壁\n苏轼“）——显示结果为题西林壁\n苏轼
输入：a=input（”今天上课去不去“）
print（a+“不去“）
七，字符串
1.名词解释：有多个字符串拼接成一个整体的数据结构——串
2.注意事项：特殊字符（%&，%￥）在字符串中有特殊意义的需要对其进行转换“//n” r”/n”
3.
（1）.字符串的创建：标识符=‘sdg’ / “sdf”
（2）.字符串中字符的获取：s=“asdfghj”
s[0],s[1]…
4.方法：获取字符串的长度——b=len(s)
5.字符串类型：s=’sji究竟是否‘
s1=“sji究竟是否”
print(s)
print(s1)
s=‘abc’
print(s[1])——输出结果为b;
**6.s,s1数据类型为字符串，若要运算print（s+‘1’),若s=’10‘，则输出101
（若要两个超级大大大得数相加，首先转换成字符串，之后再相加）
(3).切片：
语法： s[start?step]——范围[)
（注意：step表示跳转步长，中间隔的为减一，若step为负数，那么字符串为倒叙）
1.s[ :10] #从0位置截取10
2.s[2: ] #从2位置截取到len(s)+1
3.s[ : ]——从头截到尾
4.s[ : :2]——aceg
5.s[ : :-1]——gfed…
6.s[ : : -2]——gec…
s=‘abc’
print(s[0:2])——输出结果为ab;
print(len(s))
print(s.find(“b”))
s=‘abcdefgh’
print(s[5:1:-1]
print(s[-4:-7:-1])

八，数组和集合和列表：序列——数据集合
list=[1,2,3,4,5]
列表，数组，集合
名词解释：列表就是一系列数据的集合，这些数据可以是相同类型，也可以是不同类型。
例子：list=[1,2,3,4,“abc”]
C:list=[data,data…]
R:list[0]
U:list[0]=“mn”
D:del list[1]
1,列表支持len()
2.列表支持切片print（list[ : :-1])
创建列表：标识符=[‘ab’，‘cd’，‘ef’]
1=[1,2,3,4,5]
print(1）
print(type(1))
获取数据
print(1[2])
更改数据
1[len[1]-1]=20
print(1）
删除关键字
del 1[len[1]-1]=20
排序（时间复杂度）： o(1) o(n) o(n^2) o(logn)
针对一系列数据

3.方法：排序
list=[1,2,3,14,12,11,19,16]
print(list)得出来的是无序的
list.sort()
print(list)得出来的是有序的
利用列表创建矩阵：
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]
print(l)
for a in l
print(a)
矩阵值获取方法
print(l[1])获取的是l2
a=l[1]
b=a[1]
print(b)
或者print(l[1][1])
十，运算符：
1.算术运算符+，-，，/（除），//（取整除）,%(求模取余），**（求幂）
2.赋值运算符：=（赋值），+=，-=，=，/=，%=，**=，//=
a=10
print(type(a))结果为int
b=str(a)
print(type(b))结果为str
注意：只有相同类型才能进行运算
age=11
print("今年我+“str(age)+"岁”）结果为今年我11岁;
3.if判断：主要做逻辑处理，根据具体的条件来确定语句是否执行。
语法：
if condition:
pass
pass
…
elif condition:
pass
…
…
else:
pass
pass
例子：是否有钱，是否可以约，是否买花
思路：判断是否有时间，判断是否有钱
name = ‘zangsan’
salary = 100 ——花150
work = 6
if work == 6:
printf("可以出去“）
if salary >=150:
print("买花“）
else:
print("空手去吧“）
print（“再见”）
elif work == 7:
printf("可以出去“）
else:
print("不可以出去“）
print("永远再见“）
循环（遍历）目的：可以按照一定的规则对序列，集合，数据进行遍历操作
1，while
语法：
while condition：
a—— pass
…
else: ——可以没有
b—— pass——可以没有
…
如果条件成立（true）a中的代码会循环不断地执行，直到条件为flase时，循环停止。执行else中的语句（注意else和if判断一样，可以省略）
{break:结束循环
continue：结束本次循环，进行下次循环}
a=10
while a<=20:
print("成立“）
a += 1
else:
prinnt(a)
print("循环结束“）

第二种情况while a<=20:
· print("成立“）
a += 1
if a>=20:
print(a)
break
（continue）
else:
prinnt(a)
print("循环结束“）

例子：a = 10
while a<20 :

if a<15:
print(“成立”)
a+=1
continue
else:
print(“不成立”)
print(a)
例子：while循环完成1~100的求和；

九九乘法表：

2,for：对数据进行遍历
语法结构：
for 标识符（变量） in 序列：
pass
序列：一系列数据的集合——列表，字符串，dict,set,元组
for循环主要针对是序列进行遍历
例子：
1.list=[1.5.6.2.3]——遍历序列中的数据
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.number
2.string——字符串
3.list——列表
4.tuple——元组
5.dict——字典
6.set——集合
一，元组
创建：
t=(1.4.2.3.5)
读取：
print(t[1])——结果为四
（元组支持切片，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®:
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=tji(c,w,h)
print(t)
求长方体的体积同时获得表面积：
c=10
w=10
h=5
def tiji(a,b,c):
return abc
def biaomianji(a,b,c):
return cw2+
b=biaomianji(c,w,h)
t=tji(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=biaomian(a,b,c)
return abc,m
def biaomian(a,b,c):
return cw*2+
t=tji(c,w,h)
print(t)
十三，面向对象：面向对象是对现实事物的抽象。用计算机语言来模拟程序中所需要描述的事物
例子：人——买——东西（电商平台功能）——利用程序语言
人：真实存在的事物
买：动作
东西：真实存在的事物
a：字典就可以对真实事务进行描述
例子：人买一部手机
person={“name":“zhangsan”,“age”:18,“money”:200,“count”:1}
person1={“name":“zhangsan”,“age”:18,“money”:200}
item={“item_name":“phone”,“system”:“IOS”,“sell”:150,“count”:5}
item1={“item_name":“phone”,“system”:“IOS”,“sell”:150}
a=100
b=200
def buy(person,item):
if person[“count”]>2：——是否需要手机
priint("不建议购买“）
return
if person[“money”]>=item[“sell”]：
print("钱不够，去挣钱“)
return
person[“money”]=person[“money”]-item[“sell”]
person[“count”]+=1
item[“count”]-=1
buy(person,item)
print(person)
print(item)
2.买n部手机
a=100
b=200
def buy(person,item):
if person[“count”]>6 or (person[“count”]+n)>6：
priint("不建议购买“）
return
if person[“money”]<=item[“sell”]*n：
c=person[“money”]//item[“sell”]
print("钱不够，只能买%d部手机，去挣钱“，%c)
return
person[“money”]=person[“money”]-item[“sell”]*n
person[“count”]+=n
item[“count”]-=n
m = int(input())
buy(person,item,m)
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
十四，：
类：相当于一个模板和一个设计图
类种方法：每当创建实体时，初始化方法执行一次
基本数据类型：程序语言提供的
引用数据类型：
基本语法：类名首字母要大写，方法名首字母要小写。def buyComputerPerson（self）：
格式：
class person：
pass
1.创建人这个实体
p=person()——创建对象
print§
print(type§)
a=10
print(type(a))
2.class person：
def --init–（self):——初始化方法–主要针对类的属性进行定义
self .name =“zhangsan” ——self代表着当前对象
self.age=18
print(zhangsan.name)——结果为zhangsan
print(zhangsan.age)——结果为18
3.class person：
def --init–（self,name,age):——初始化方法–主要针对类的属性进行定义
self .name =name ——self代表着当前对象,设置属性，并且赋值。
self.age=age,
zhangsan=person(“zhangsan”,18,150)
print(zhangsan.name)——结果为zhangsan
print(zhangsan.age)——结果为18
lisi=person(“lisi”,28,350)
print(lisi.name)
print(lisi.age)
print("初始化“）
def test(self):——必须含self属性，才能表示函数可以被调用。
print(”-------test------“)
zhangsan.test()
def pri(self):——self为共享的
print(self.name)
print(self.age)
zhangsan.pri()
lisi.pri()
def --init—（self,item_name,sell):
self.item_name=tem_name
self.sell=sell
def pri（self)
print(self.item_name)
print(self.sell)
zhangsan=person(“zhangsan”,18,150)
zhangsan.pri()
phone=item(“华为—P30”,“android”,6550,20)
phone.pri()
zhangsan.buy(phone)
(if self.count>6:
print()
return
if self.money<phone.sell:
print("用户名：“self.name+"年龄：”+str(self.age)+"存款：“str（self。sell)）
self.money+=phone.sellp
self.count+=1）

创建一个类：
class person:
cry=“wawawawawa”——
类属性:所有对象都可以共享,
直接可以通过类直接调用，
类属性主要定义的是针对所创造的所有对象的共性特征
self可以直接调用类属性
在类的方法中，也可以通过
def–init–(self):
self.name=“zhangsan”——实例属性
print("—初始化—")
def test(self):
print(self.cry)——结果为wawawawawa
print("—test—")
p=person()
p.test()
print(p.cry)——结果为wawawawawa
print(person.cry)——结果为wawawawawa
def cry(self):
print(“wawawawawa”)
def test(self):
print(self.cry)
print("—test—")
p=person()
p.test()
类方法：
在类上加上装饰器
修改方法中的变量cls
cls实际就是当前类：person（类名）
@classmethod
def cry(self):
print(“wawawawawa”)
def–init–(self):
self.name=“zhangsan”——实例属性
print("—初始化—")
def test(self):
print(self.cry)——结果为wawawawawa
print("—test—")
静态方法：
1，方法上加上装饰器@staticmethod
@staticmethod
def stat ():
print("-----这是静态方法-----“）
类方法与静态方法的区别：
类方法中包含cls变量，而静态方法中不包含cls变量。
继承：object是所有类的父类
作用：
1.子类对象可以使用父类方法以及属性。
2.父类不可以调用子类的方法。
3.多层继承，子类可以调用多级父类的方法
4.多继承：一个类可以继承多个类的方法和属性
5.当多个父类中有相同的方法时，子类优先调用写在前面的方法
class person（object）：——object是所有类的父类
def eat（self）：
print(“吃饭“）
class user（person）：
def buy（self）：
print(”—会购物----“）
u=user()
u.buy()
u.eat()
class Person(object):
def eat (self):
print(“吃饭”)
class User(Person):
def buy (self):
print("-----会购物------")
class Boy (object):
def sport (self):
print("-----游戏-----")
class Girl(object):
def sport (self):
print("-----瑜伽-----")
class Student(Girl,Boy):
def study (self):
print("-----学习-----")

class AA:
pass
s = Student()
s.sport()