关于Python的学习笔记

初识---------------------------------------------------------

数据类型和变量

字符串(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);#列表查找到打印后续，如果是字典则打印对应的键值，如果查找无结果就遍历全部