初识---------------------------------------------------------
数据类型和变量
字符串(string) //‘pork’ ‘辣椒’
数字(number) // 0.5 5
列表 //['盐','芝麻','花椒']
字典 //{'name':'王伟','age':25,'school':'新东方'}
逻辑(Bool) //True(真) False(假)
变量 //变量可以变化,存放不同的东西
//pot = ‘辣椒’ listBox = ['盐','芝麻', '花椒']
流程控制
判断语句(if)
if(fire == '大火'): #注意有冒号
print('翻炒10下') #注意冒号下的分支程序要 Tab键缩进
else:
print('翻炒20下')
分支判断语句(if…elif…else)
age=12; #//要顶格写
if(age<18): #//true 逻辑成立为真
print('未成年'); #//注意要有缩进
else: #//false 逻辑不成立为假
print('成年');
#//注意: python里无switch
a =1;
#a =0;
a ='lili';
#a ='';
a ={
'name':'lili'};
#a ={};
if(a): #//真的 True 非零数字 非空字符串 非空对象
print('真');
else: #//假 False 数字零 空字符串 空对象;
print('假');
循环语句(for/while)
count=0
while(count<10):
count = count+1
print('翻炒'+str(count))
for i in range(1, 10):
for j in range(1, i + 1):
print('{}*{}={} '.format(i, j, i * j), end='') #//end指定结束方式,如不指定,将默认换行
print('')
#//遍历对象元素
box = ['banana', 'apple', 'book']
for e in box:
print(e);#列表查找到打印后续,如果是字典则打印对应的键值,如果查找无结果就遍历全部
for x in 'Python': #//遍历
print(x);
#遍历一个数字序列
for i in range(5):
if(i==2):
break; #//跳出终止整个循环
#//continue; 跳过本次循环,继续下一次循环
print(i);
#找出偶数值
for num in range(2, 10):
if num % 2 == 0:
print("找到一偶数:", num)
continue
函数
定义函数(def)
def do_xcr():
print("hello world")
print("准备食材")
print("炒菜完成")
调用函数
do_xcr()
do_xcr()
do_xcr()
类(类似结构体)
class Person: #//定义类(只是想法)
name = 'lili' #//类属性
def talk(self): #//类行为(方法):形参self必须有,代表类的实例
print("can talk,my name is:",self.name);
p = Person() #//新建类的实例对象
p.talk() #//调用对象的方法(无参,但其实有参,它是隐藏的第一个实参,为类的实例)
print("name is",p.name) #//访问对象的属性
p.age=30 #//可动态添加(python是动态语言)
print("new age is",p.age)
库(import)
#//官方文档 https://docs.python.org/zh-cn/3/
import random #//随机数库
print(random.random())
import time; #//时间的库
print(time.ctime())
import math; #//数学库
print(math.gcd(4,12));
from time import sleep,ctime//导入time函数库中的sleep,ctime函数
输入输出(input/print)
a = input("请输入: ")
print(a, type(a))
print('%s %d %c %x'%('ivan',10,65,15)) #//老版本格式化输出: 字符串 整型 字符 16进制
i = 2
j = 5
print('{}*{}={} '.format(i, j, i * j))
#//新版格式化输出: 0指format的第一个对象(如3),1指format的第二个对象(如10),
#// {1:x} 冒号前指对象,冒号后指定输出类型(b:二进制,x:16进制)
print('{0}二进制:{0:4b} {1}十进制:{1:d} 16进制:{1:x}'.format(3,10))
异常(try)
x=3
y=0
try: #//如无异常判断将终止退出,不能继续往下执行
print(x/y)
except :
print("can not be zero")
print("go go go")
语法
#//---关键字(保留字) --> 保留字不能用作常数或变数,或任何其他标识符名称 ,python 关键字全小写
print pass assert
if else return for while continue break
class try
def with import from is finally lambda
= + - * %
#//---语句
counter = 100; #//语句:把整型数据100赋值给变量counter (;表示语句结束,可省略).
name = "John" #//字符串类型
price = 2+3+5; #//表达式语句
Price = 8; #//区分大小写(price 和Price不是同一个)
#//---注释
# #//单行注释
''' 多行注释 ''' #//多行注释:三个单引号或双引号
""" 多行注释 """
#//---字面量(直接量) --> 直接用的数据值(如 print(34+5))
34 'ivan' True False #//基础类型: 数字 字符串 bool值。
[2,3,'ivan',5] #//列表 train= [2,5,'ivan',False]
#//print(train) train[2]=55 print(train)
(1,5) #//元祖 a=(1,5) a[0]=3; 改写会失败
{
'name':'lili','age':30} #//字典 b={'name':'lili','age':30}; b['age']=20;
#//print(b); print(b['name']);
字面量就是比如说int a = 1; 这个1就是字面量 ,a是变量名
又比如String b = “abc”;这个abc就是字面量,b是变量名
变量与数据类型---------------------------------------------------------
变量定义赋值
age =3; #//变量赋值(实现,获得空间)
#//1age =5; (报错 命名:数字不能在前)
name = 'ivan'; #//变量赋值字符串类型
girl = {
'name':'lili','age':30}; #//变量赋值字典类型
a,b=1,2; #//多重赋值, 拆解为 a=1; b=2;
a = b = 1; #//连续赋值, 拆解为 a=1; b=1;
基础数据类型
number: 数字(整形 浮点型 复数)
a,b,c = 10,3.14,1+2j
print(a,b,c)
print(a+c)
print(c,type(c))
字符串
str = 'hello baby';
print(str,str[1],str[2:4],str[6:]);
复合数据类型
列表对象(升级数组:放置任意类型数据)
train = [50,20,'apple'];
print(train);
list = train;
train[2] = 'tv';
print(train);
print(list);
元祖对象(只读数组[禁止修改])
tuples = (1,6,'ivan',3,'good',77);
print(tuples); #//输出 (1,6,'ivan',3,'good',77)
print(tuples[1]); #//输出 6
print(tuples[1:3]); #//输出 (6, 'ivan')
tuples[1]=2; #//报错,元祖是禁止修改的
tu2 =(56,'yzg',3)
print(tuples+tu2) #//拼接
print(tuples[2.0]) #//报错:TypeError: tuple indices must be integers or slices, not float
#原因时类型不匹配,需把2.0 转为int 用 int(2.0)
集合对象(内部无序/不重复)
basket = {
'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket);#打印不重复
print('banana' in basket);#只能返回有无,不能返回序号
字典对象(键值对)
man={
'name':'ivan','age':30};
print(man);
obj={
}; #//定义空的字典对象
obj['name']='yzg';
obj['age']=28;
print(obj['name'],type(obj));
man = obj;
obj['age'] =10;
print(man);
空间分配(引用地址)
str1 = "ivan";
str2 = str1; #//赋值是 引用的拷贝(引用是指向实体的地址)
print(id(str1)) #//id() 是查看对象的存储地址
print(id(str2))
print('str1 = ' + str1);
print('str2 = ' + str2);
str1 = "yzg";
print(id(str1))
print(id(str2))
嵌套引用(引用地址)
train = [50,20,'apple'];
train[1] ={
'name':'lili','age':30}
print(train)
#//可把函数名,看成指向代码块的引用
def gogo():
print("i can gogogo")
train[1]['teach']=gogo
print(train)
train[1]['teach']()
数据运算
算术(+ - * ** / %取模(求余) ****幂 // 取整除)
print(6+3*5/2);
#//---浮点型精度问题(因二进制,0.333表示有问题)运算中有0.3出现都会有问题
print(0.3-0.2); #输出0.099
print(0.1+0.2==0.3); #输出 false
#//解决方法:放大后再缩小
print((10*0.1+10*0.2)/10==0.3); #输出 true
#//---% 取模(求余)
print(3%2); #单双数判断
#//---优先运算加 ()
print((10+20)/2);
print(2**3); #//2的3次方(幂)
print(9//2); #//取整除 为4
赋值运算(= += -= *= /= %= **= //=)
a=2;
a+=3 #//与 a = a+3; 相同
print(a);
a%=2; #//与 a = a%2; 相同
print(a);
a**=3
print(a);
a = 9;
a//=4
print(a);
比较 (< > <= >= == !=)
age =18;
if(age>=18):
print('成年');
today ='11.10';
if(today!='11.11'):
print('双11还未到');
a=2;
b='2';
if(a==b):
print('值相等');
位运算(&与 |或 ~非 ^异或 <<左移 >>右移)
a=60 #//对应二进制00111100
b=13 #//对应二进制00001101
print(a&b) # 00001100
print(a|b) # 00111101
print(a^b) # 00110001
print(~a) # 11000011
c=4 # 00000100
print(c<<1) # 00001000
print(c>>1) # 00000010
逻辑运算(and与 or或 not非 in not in is is not)
age =25;
print('是青年吗 ',(age>18 and age<30));
hasHouse,money =True,1000;
#hasHouse,money =False,1000;
if(hasHouse or money>1000000):
print("有房或有100万,嫁给他")
if not(hasHouse or money>1000000):
print("即没房也没100万,不嫁")
list = [1,2,3,4,8];
print('3在list中吗',3 in list);
print('6不在list中吗',6 not in list);
lili = {
'name':'lili','age':30};
x = lili;
x['name']='linda';
print(x,'是lili这个人吗',x is lili);
类型转换
#//int() 转换为整型数字
print(int(3.14)+2);
print(int('12')+5);
print(int(0xa)+3);
#//转float
print(float(3)+1.24);
#//str() 转换为字符串
print(str('12')+'5');
lili = {
'name':'lili','age':30};
print(str(lili)+'good');
print(lili+'good'); #fail
#//隐式转换(自动转换)
name = 'ivan'; print(name[1]); #//字符串转换为列表 --> 查找某位置的字符
print( '7'+'people'); #//数字转换为字符串 --> 进行拼接
print( '7'-'people'); #//报错:隐式转换失败
函数---------------------------------------------------------
(描述如何做事的逻辑代码块 -> 封装(隐藏 复用))
初识
定义声明
#//关键字:def -- 让系统识别 这是函数
#//函数名: start -- 名字 (事情的名称, 注: 定义多个函数时名字不能相同)
#//函数体:冒号后缩进的代码块 -- 内容(描述事如何做)
def start(): # 定义(规划做什么事)
print('starting... machine ');
print('start success');
调用
start(); #调用(开始做事)
start(); #可调用多次 (封装隐藏 --> 复用)
传参
def start(name): #//函数参数: () -- 输入(做事需要什么东西, 如 name)
print('start '+ name +' success');
start('iphone');
start('pad');
def start2(n): #//形参 n (相当于局部变量)
#//n = a; 参数n 相当于局部变量,
print('start '+ n +' success');
a ='iphone';
start2(a); #//函数传参, 类似于变量的赋值 n = a;,把实参赋值给形参
函数作用域
def fn():
age=35; #//局部变量
print('in fn age= ', age);
fn();
print('age =',age); #//报错,外面不能访问里面变量
定义声明
空函数(pass//空位)
def sum(n): #//空函数
pass #//占位,什么也不做
sum();
具名函数(def//关键字)
//关键字:def -- 让系统识别 这是函数
//函数名: start -- 名字 (事情的名称, 注: 定义多个函数时名字不能相同)
//函数体:冒号后缩进的代码块 -- 内容(描述事如何做)
def start(): #//函数声明定义(规划做什么事)
print('starting... machine ');
print('start success');
start(); #//函数调用(开始做事)
start(); #//可调用多次 (封装隐藏 --> 复用)
fn = start; fn(); #//函数名赋值给变量,可间接调用
做对象里的方法(函数引入对象中)
做类里的行为(方法)
class Person:
name = 'ivan'
def speak(this):
print(this.name,'can speak');
ivan = Person();
ivan.speak();
做字典里的一个值
def fn():
print('driver bus');
person ={
'name':'ivan',
'driver':fn
}
person['driver']();
传参(函数输入口)
person = {
'name':'yzg',
'age':30
}
def changeName(p): #//局部变量 p = person (person里存放的是引用地址 如028)
p['name'] = 'ivan';
changeName(person);
print(person);
字符串/数字/布尔值----->传参
x = 'iphone'; #//或x = 30 , x = true;
def fn(v): #//函数参数: () -- 输入(做事需要什么东西, 如 v)
print(v,' type: ',type(v));
v = 'android';
fn('iphone'); #//传字符串(或 数值6000 布尔值)
print(x);
列表----->传参
a = ['ivan','yzg','lili']
def change(addr):
addr[1]='wangwei';
change(a);
print(a);
函数----->传参(回调函数)
def fn(callback): #//函数参数: () -- 输入(做事需要什么东西, 如 callback)
print(callback,' type:',type(callback));
callback(); #//通过参数,间接调用函数 (回调函数)
def start():
print('start tv');
fn(start); #//函数做参数传入
字典对象----->传参
f car(): print(' dirver car'); #//需先定义,后再使用
def bus(): print(' dirver bus');
person ={
'name':'ivan',
'driver':car
}
def change(obj):
obj['name']='yzg'; #//更改对象的属性
obj['driver']= bus; #//更改对象的方法
change(person);
print(person['name']);
person['driver']();
类对象----->传参
class Animal: #//定义对象 Animal
name = "animal";
def breath(this):
print("can breath from water");
def air():
print("breath from air");
def change(o):
print("after change");
o.breath = air;
obj = Animal(); #//新建对象实例
print(obj.name);
obj.breath();
change(obj); #//对象做实参(引用类型传递 是地址传递,指向的是同一实体)
print(obj.name);
obj.breath();
不定参(带入元祖字典)
*args 传入的参数是 元组类型
def test(*args):
print(args)
for i in args:
print(i)
test(1,2,3)
**kwargs 传入的参数是 dict 类型
def test(**kwargs):
print(kwargs)
keys = kwargs.keys() #获取键名
value = kwargs.values() #获取键值
print(keys)
print(value)
test(a=1,b=2,c=3,d=4)
**多个数累加和
def sum(*args): #//args里存放了所以的实参
ret = 0;
for obj in args:
print(obj);
ret += obj;
print('sum is', ret);
return ret;
sum(1);
sum(1, 4, 3);
返回值(return)
返回number string
def sum(x, y):
return x + y; #// 函数返回值:return -- 输出(做完事后能得到什么)
#// 注:无return时,返回None, return 后面语句不执行
print(sum(3, 5)); #// 传参调用
返回函数
def fn(a):
print('fn run');
def fnn(b):
print('fnn run ..');
return a+b;
return fnn;
print(fn(10)(20));
作用域(局部全局)
country = 'china'; #// 全局变量(任意地方用)
def fn(): #// 函数作用域分函数内外
country = 'yindu';
age = 35; #// 局部变量
print('fn: ', country);
print('fn: ', age);
def fn1(): #//局部函数
print('fn1 go ');
print(country);
fn();
print(age); #// 不能访问函数内部资源, 故报错NameError::age is not defined
fn1(); #// 局部函数不能访问
作用域链
函数嵌套 --> 形成链条 --> 变量回溯(当前没有,沿着链条追查上家)
name = "first";
def fn1():
name = "second";
def fn2():
print(name); #// 变量回溯(当前没有,追查上家)
fn2();
print(name);
fn1();
print(name);
fn2(); #// fn2是局部函数,不能访问
例:下面程序输出信息是
country='china'; #//全局变量(任意地方用)
age =80;
def fn():
country = 'yindu';
print('2 level country is ',country);
name1 = 'ivan'; #//局部变量(只能在函数内部用)
age =30; #//同名时,在局部作用域内(函数内),局部变量有效。
def fn(): #//嵌套子函数
print('3 level name is ',name1); #//子函数可用父函数作用域内的变量
age =8;
fn();
print('2 level age is ',age);
fn();
print('1 level age is ',age); #//80 同名时:函数外,全局变量的有效
print('1 level name is ',name1); #//不能访问局部变量 NameError: name 'name1' is not defined
例:下面程序输出信息是
i=0;
def fn1(i):
print( 'i = ',i);
a = [1,2,3];
def fn(callback):
for i in range(3):
a[i] = callback;
callback(i);
fn(fn1);
a[0](i);#由fn(fn1)后 a[]代指fn1
a[1](i);
函数式编程(面向映射)
命令式编程(面向过程): 关心执行步骤,有变量,表达式,控制语句等 -> 解决步骤(告诉机器 怎么做)
元编程(面向对象): 以对象(独立个体)为核心,组织数据和关系 -> 找对象(告诉机器 是谁做的)
函数式编程(面向映射):像数学函数(表达式)一样计算,无需更改状态和数据 -> 映射关系(告诉机器 做什么)
不变性(没有可变的状态,不依赖也不改变外面状态,引用透明,和没有副作用)
适合并发编程(没有状态的上锁)
当把函数也看成数据,输入确定,输出也确定 -> 无状态化(因为一旦独立投入计算,我们没有和其他人同步的要求了)
匿名函数(lambda 中间处理 无需命名)
fn = lambda x:x+10; #//创建匿名函数lambda,让变量fn 指向它
#//lambda:冒号 左侧表示函数接收的参数x ,右侧表示函数的返回值x+10
#//等价于 def fn(x):return x+10
print(fn(1));
print((lambda x:x+10)(3)) #//可定义调用一气完成
c = lambda x,y=2: x+y //默认值
print(c(10))
L = [(lambda x: x**2),(lambda x: x**4)] //字典中
print(L[0](2),L[1](2));
print((lambda x,y: x if x> y else y)(3,5)) //求最值(类三目运算)
面向对象
class Actor: #//定义类(只是想法)
name = '赵丽颖' #//类属性
age = 35
def act(self): #//类行为(方法):形参this必须有,代表类的实例
print(self.name," 会演戏")
def sing(self):
print(self.name," 会唱歌")
obj = Actor() #//创建类的实例对象
print(obj.name) #//访问对象的属性
print(obj.age)
obj.act() #//调用对象的方法(无参,但其实有参,它是隐藏的第一个实参,为类的实例)
obj.sing()
#//动态语言:可动态添加属性和方法(python是动态语言,不像c++静态语言,定义完后,后面不能修改)
obj.addr="成都" #//动态添加属性
print(obj.addr)
def show(self):
print(self.name,self.age,self.addr);
obj.show = show; #//动态添加方法
obj.show(obj) #//动态添加的要传入对象势力,不能隐藏
obj.sing()
继承
class Animal: #//定义类(只是想法)
name = 'animal' #//类属性
def eat(self): #//类行为(方法):形参self必须有(类似this),代表类的实例
print(self.name," can eat")
def breath(self):
print(self.name," can breath")
def run(self):
print(self.name," can run")
#//父类:通常是抽象出来的
继承:复用(不用重复写父类方法)
扩展:子类Cat在继承父类Animal的能力eat,run基础上,可派生新能力,如catchMouse
隐藏:子类会把父类的同名方法挡住
类的使用
默认处理解决异常报错
c = Cat() #//新建类的实例对象c
c.catchMouse()
c.breath()
c.run()
f = Fish() #//新建类的实例对象f
f.eat();
f.breath('water');
f.swim();
f.breath(); #//会报错参数个数不匹配,因子类会隐藏了父类的同名函数,
#//1.用默认参数解决
#//def breath(self,str='water')
#// print(self.name," can breath from ",str)
#//注意:用重载不行,下面的同名函数会覆盖上面的同名函数,不会智能匹配参数个数
#//2.用不定参
多态(未来性)
python 天生多态(动态语言,运行时动态绑定)
def play(obj):
obj.breath() #//使用者在不知道具体对象情况下,直接掉接口breath.
#//breath会根据对象做调整
play(c);
play(f);
构造函数析构函数(类的初始化)
class Line:
name='a line'
def __init__(this,len=3): #//可选,无时,会有默认的
this.length = len
print('构造函数运行')
def __del__(this): #//可选,无时,会有默认的
print('析构函数运行,释放资源')
def show(this):
print('length is',this.length);
obj = Line() #//创建对象实例时,自动调用构造函数。
obj.show(); #//执行完自动析构(引用计数方式,进行垃圾回收)
权限(天然全开放)
问题集:
没有打印为什么会有打印信息
待验证:
box = [‘banana’, ‘apple’, ‘book’]
for e in box:
print(e);#列表查找到打印后续,如果是字典则打印对应的键值,如果查找无结果就遍历全部