#变量包括,地址、类型、值,是动态类型的
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;