Python学习笔记-1(变量、类型、函数、类、作用域)

#变量包括，地址、类型、值，是动态类型的
a="123"     #动态类型：在运行时,根据它的值来决定的类型
b =int(a)   #将强转类型生成数字123，注意，此时a并没有改变
id(a)       #取得变量a的引用，即地址
type(a)     #取得变量a的类型，<type string>
a is b      #地址比较，还有not is
global a;   #声明a是全局变量，注意是声明不是定义，具体后面再说

一、Python内部类型

#数字类型int\long\float\complex： 2+3J, 123L
#其中long末尾加L\l   complex是复数，末尾加j\J表示虚数
boolean:    a=True/Flase;   #注意首字母是大写的
string:     a="str", a='str'，a="""str""",a='''str''';#可换行字符串
tuple:      a= (1,2,"str"); 
list：       a = [1,2,"str"];#注意，是可以不同对象的
dict:       a = {key:1};    #相当于map
set:        a= set((1,2,1));#无序不重复集合，以可iterator的数据结构(list,tuple等)为参数传入数据，可通过&,| 取交集并集等


#dict中有一个方法itervalues()、iteritems() 等常用
for k,v in d.iteritems(): pass;

其中int/bool/string/tuple/set 对象是不可变的(常量对象)，list/dict对象是可变的。
可变不可变是对地址来说。如a=123;a=”str”，是a指向了新建的对象，int类型的（123）地址不变，而list、dict却可以在自身地址上修改值*

类型转换：

Type(a [, base])，把a转换为base进制的Type类型

int(x [,base ])         #将x转换为一个整数  
long(x [,base ])        #将x转换为一个长整数  
float(x )               #将x转换到一个浮点数  
complex(real [,imag ])  #创建一个复数  
str(x )                 #将对象 x 转换为字符串  
repr(x )                #将对象 x 转换为表达式字符串  
tuple(s )               #将序列 s 转换为一个元组  
list(s )                #将序列 s 转换为一个列表  
chr(x )                 #将一个整数转换为一个字符  
unichr(x )              #将一个整数转换为Unicode字符 
eval(str)   #用来计算在字符串中的有效Python表达式,并返回一个对象
ord(x )     #将一个字符转换为它的整数值  
hex(x )     #将一个整数转换为一个十六进制字符串  
oct(x )     #将一个整数转换为一个八进制字符串  

二、语句 、运算符等

#if-else; def函数 for while都需要加冒号":"

def fun():          #函数声明。//代表取商的整数部分，x**y代表x^y
    a=3**2          #以"换行或分号"为一条语句。      
    a=3.0//2  \     #相同"缩进"的一组语句代表语句块(作用域)                 
    +7              #若一行写不下，可以用 "\"代表和下一句连接list,tuple,dict可以"换行符"分割一行

    if(a<>7):       #<>不等于，也有!=不等于
        print "a!=7" 
    else:           
        print "a==7"
    return 0


for i in "123456":  #in 、not in是取成员运算符，注意，不能加()
    print i;       

while i < 9: 
    print "while:",i;
    i=i+1;         
else:   #for/while-else，else将在正常执行完循环后(不是break出来的)执行
    print "完成"

if a==0:
    pass            #空语句

print a and b       #逻辑与，如果a==0，返回a，否则返回b的值
print a or b        #逻辑或，若a!=0，返回a，否则返回b的值
print not a         #返回True、Flase

注意：Python不支持Switch语句，没有++ - - 操作符，只有行注释(#)，没有专门的多行注释符(一个匿名字符串就可以当多行注释)。

---

三、字符串

 四种写法：'字符串'、"字符串"、'''可换行字符串'''、"""可换行字符串"""
s = "pythonString"
a = s[-1]               #从左到右索引0=-0开始，从右到左索引-1开始
b = s[0:-2]             #子串，表示[0,-2)，
c = "str"*2             # * 是字符串重复符，重复n次
#R/r 放字符串前，指定为原始字符串，字符串内的特殊符号（如\n换行）无特殊意义
c = R"str\n"            #  "123\\n123\\n"


----------
字符串连接
c = "he"+"llo";     c="he""llo";    # + 是字符串连接符，可省略
#%s、%d是占位符，%是连接符，若没有，那么%s、%d将当做普通 字符处理
c = "he%s%d" "llo"      #等同于 R"hello%s%dllo"

#命名替换，将占位符扩展为有名字的变量，通过后面的字典中名称的值来替换
c = "12%(a)s%(b)d" % {"b":4,"a":"3"}    #1234

#.format()，若匿名，将按顺序取值
c = "12{a}{b}".format(b=4,a=3)          #1234

四、函数和参数

1.函数要先定义，然后才能使用。
2.参数按引用传递。
3.return语句可省略，将自动生成return None
4.有__name__属性，代表自身函数名

def fun(a,b=1):pass     # 和C++一样，缺省参数b=1
fun(b=2,a=10);          # 调用时，可以匿名顺序传入，也可以命名乱序传入

#lambda有自己的名字空间，不能访问参数列表之外或全局名字空间里的参数。
#lambda 只能写一行，不能赋值，内部也不能定义等等
sum = lambda arg1, arg2: arg1 + arg2;   #匿名函数(lambda)

#变长匿名参数：（*）的变量名会存放所有匿名的变长参数,实际是以tuple存储
#变长命名参数(**)的变量名会存放所有多余的命名参数，以dict存储{key:v}
def fun(*args,**kwags):
    print args          #通常约定变长参数名称为args和kwargs
    print kwagrs

高阶函数：函数作为参数传入

#对seq上的每个数据，调用fun(arg)，并返回结果list,fun只能接受一个参数。
list = map(fuction,sequence[,sequence])

#对seq上的数据调用把fun(),并把结果和 下一个元素做累积运算：fun( fun(arg1,arg2), arg3 )...
value = reduce(fuction,sequence[,inital]

#对seq上的数据调用fun，返回值是 True/False:保留/丢弃该元素。bool fun(arg);
list/tuple/string = filter(fuction or None,sequence);  

#cmp(x,y) >0代表x>y, <0 代表x<y  
list = sorted(iterable , cmp = None, key =None,reverse = False);  


#把func中的某些参数设置为固定值(一般要求命名传入)，返回新函数
newFunc = functools.partial(func,*args,**keywords);

五、类

1、类只是强制绑定了变量，每个实例对象可以自由地绑定 数据变量
2、类中函数第一个参数永远是实例变量“self”，代表自身对象。系统自动传入。
由于每个实例对象可自由绑定新的属性，所以可以通过self来绑定新属性，或设定属性值
3、多继承父类中有相同的方法名，python默认在子类中未找到时，从左到右查找父类

class Son(Father1,Father2): #多继承自Father1,2类
    __i     #私有变量(__开头)，只能被self对象访问(也就是只能内部函数访问)
    def __init__(self,i): #构造函数，在生成对象时调用
        pass
s = Son(1);             #调用构造函数__init__生成对象

类中特有的其他方法：

__init__(self,args) :构造函数，在生成对象时调用
__del__(self)       析构函数，释放对象时使用
__repr__(self)      打印，转换
__setitem__(self,n) 按照索引n赋值
__getitem__(self,n) 按照索引n获取值
__getattr__(self,name)  返回属性name的值时，调用
__len__     获得长度，obj.len()时调用
__cmp__     比较运算，obj.
__call__(self)  对象直接当函数 调用时转化为调用__call__()
__str__()   当对象被转化为string时使用    
__iter__()  当对象被遍历时，调用__iter__(self)返回一个可迭代的对象

__add__             加运算
__sub__             减运算
__mul__             乘运算
__div__             除运算
__mod__             求余运算
__pow__             乘方

#属性：
__dict__ 存类变量和值的dict

六、作用域问题：

只有模块、类、函数 才会引入新的作用域，其他代码块中的变量，都是全局的
变量名查找是动态的，也就是说，在使用变量前，Python能查看到变量是在哪定义的，在使用一个变量之前，必须要已经绑定到某个对象上

#注意，python一行行解释代码，fun()调用处开始才会执行fun()内部代码

#情况1：函数作用域内，定义了变量i，将隐藏外部变量
i=1;
def fun():
    i=1;
    print i;

#情况2：报错。因为python能动态查找到在fun的作用域内定义了变量
#那么在print i时，必须要先绑定了才能使用
i=1;
def fun():
    print i;
    i=1;
#情况3：使用global显示引入外部变量，则fun作用内所有i都是指向外部变量
i=1;
def fun():
    global i;
    print i;
    i=1;