python 语言基础 - archering/basic GitHub Wiki
print("hello world") // 控制台输出打印文字
#(井号)单行注释
变量声明 变量名 = 变量值； //和js类似 ，但没有关键词var，let等, 无需指定类型
msg = "hello world"
num = 1990
变量必须以 字母或**下划线_**开头， 由字母数字下划线组成，其他字符为非法字符，会导致程序运行不下去，大小写敏感。
_name = "sadasd"
name12="sssss"
注意，非法变量或者未声明变量并不会打印出 undefined 而是直接 报TypeError
python的标准类型 (类型都是小写字母)
int （不含小数点，整数）
float （含小数点）
str
tuple (immutable) //定义后，数组个数不能改变
list (mutable)
dictionary : key-value pairs
bool 类型， True False 大写首字母
e.g 打印结果如下，type() 函数会输出变量类型 ,也可以通过 isinstance([],list) // true 判断是否是某个类型实例
num1 = 100
print(type(num1))
<class 'int'>
num2 = 19.2
print(type(num2))
<class 'float'>
message = ("no1",119011,"this is a message")
print(message[0])
print(message[-1])
// no1
// this is a message
message[0] ="no2"
print(message[0])
// 报错 TypeError: 'tuple' object does not support item assignment
tuple 不能被枚举
List
li = [1,2,3,"hello",[1,2],11.9]
print(li[0])
//1
li[0] = "this is hello"
print(li[0])
// this is hello
li[0:3] //[1,2,3] 取前三个切片（slice），0 可以省略 -1 表示倒序
list(range(1, 11)) // 生成一个数组 [1,2,3,4,5,6,7,8,9,10,11]
[x * x for x in range(1, 11)] // [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
上面程序等同于
L = []
for x in range(1, 11):
L.append(x * x)
L
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[m + n for m in 'ABC' for n in 'XYZ']
// ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
Dictionary : key可以使任意类型，获取字典的值只能通过 bye[key] ,无法通过序号 和js object不同
bye = {"a":"hello world",8:"this me",num1:1900}
print(bye["a"])
print(bye[8])
print(bye[num1])
Type Casting 强制类型转换
input() // 命令行prompt 窗口，用户输入，返回用户输入值
age = input("your age is :") // 运行到这里，会出现光标闪动，请用户输入并回车
print("you just typed your age is :"+age)
na = input("your name is :")
print(type(na))
print("name is :" , na)
str(10) // "10" 强制转成字符串
数字类型强制转换
print(int("12")) //12
print(float("12.35")) //12.35
print(float("12")) //12.0
print(int("12.1")) // ValueError 不能转
python四则运算符号
+ - * / % ** //
x = 100
y = 10
z = 3;
print(x+y) //110
print(x-y) //90
print(x/y) // 10.0
print(x*y) // 1000
print(x%y) //10 取余
print(x**y) //100的10次方
print(x//y) // 除以后再取 floor
print(x/z) // 33.33333333333333
print(x//z) // 再取floor 33
print(y**z) // 10的3次方 1000
python逻辑操作符 not ，and，or
print(not 1) //False
print(not 0) //True
bo = True;
print(not bo) // False
print(1 and 0) // 0
print(1 and True) // True
print(True and 100) // 100
print(100 and True) //True
print(100 or True) // 100 第一个就满足条件，直接打印
print(True or 100) //True
#### python 比较
x = 100
y = 10
print(x==y) //False
print(x>y) //True
print(x!=y) //True
if--elif---else
if x == y : print("yes")
elif x>y : print("yes2")
else : print("yes3")
// yes2
if (y<=z): print("hello1")
elif (y>z):print("hello2")
else: print("hello3")
//hello2
in , not in, is ,not is
a = "hello world"
b = "world"
print(a in b) //False
print(b in a) //True
print(a not in b) //True
c = [1,2,3,4]
d = [4,5,6,7]
e = c
print(c is d) //False
print(c is not d) //True
print(e is c) // True
print(3 in c) //True
while
while i<10:
print(i)
i+=1
//打印出 0，1，2，3，4，5..... 9
for
j = 0;
for num in range(j,10,1):
print(num);
//打印出 0，1，2，3......9
range(start, stop , step)
j = 0;
for num in range(j,10,1):
if(num == 5):continue //5 不打印出，继续下一个循环
print(num);
j = 0;
for num in range(j,10,1):
if(num == 5):break // 只打印，0，1，2，3，4
print(num);
for x, y in [(1, 1), (2, 4), (3, 9)]:
print(x, y)
//1 1
//2 4
//3 9
>pass是空语句，是为了保持程序结构的完整性。 pass 不做任何事情，一般用做占位语句。
function
def sayHello(name):
print("your name is ",name)
def sayHello2(name="zhangdong"):
print("u name is ",name)
sayHello("kkk")
sayHello2()
def sum(a,b):
return a + b
print(sum(1,2))
def divide(a,b):
"you must type two args"
return a / b
print(divide.\_\_doc\_\_)
print(divide(100,10))
def multi(a,b,c):
"xian jia"
d = a + b;
"hou cheng"
print(d * c)
print(multi.\_\_doc\_\_)
print(multi(1,2,3))
匿名函数
sum2 = lambda arg1,arg2: arg1 + arg2`
print(sum2(99,1))`
print( (lambda arg:print(arg))("hello123") )
class
__ 开头的变量是私有变量或者私有成员方法
__init__() 构造函数，在生成对象时调用
__del__ 析构函数，释放对象时使用
__len__获得长度
__cmp__比较运算
__call__函数调用
__setitem__按照索引赋值
__getitem__按照索引获取值
class People:
name = ""
def \_\_init\_\_(self,gender,age,nation):
self.gender = gender
self.age = age
self.__nation = nation
def getGender(self):
print("your gender is :",self.gender);
def getAge(self):
print("your age is :" , self.age)
p = People("M",30,"china") //类的实例化，不需要new 关键字，参数传递与否主要看 __init__(self, 后面的参数)
p.getGender()
p.getAge()
在python 类中，变量名如果以__开头，就变成了一个私有成员private，这样就可以实现封装
class People:
name = ""
def __init__(self,gender,age,nation):
self.gender = gender
self.age = age
self.__nation = nation
def getGender(self):
print("your gender is :",self.gender);
def getAge(self):
print("your age is :" , self.age)
def getNation(self):
print("natio nis :" + self.__nation)
p = People("M",30,"china")
print(p.gender)
print(p.age)
print(p.getNation())
print(p.__nation) //报错， 私有变量，无法访问，只能通过public的方法访问
继承 inheritance
class Male(People): //参数为要继承的父类名,不写参数，默认继承自object
def sayHello(self): // 父类没有的方法
print("hello world")
def getAge(self): //override People 已经有的方法
print("this is overrided function,for print your age:" + str(self.age))
m = Male("M",20,"chinese")
print(m.getAge())
print(m.sayHello())
print(isinstance(m,People)) //True
print(isinstance(m,Male)) // True
更改初始化参数的继承
class Female(People):
def __init__(self,name,age,gender,nation): //这里参数顺序和个数和People已经不同了
super(Female,self).__init__(gender,age,nation) //super 掉一下父类的初始化函数，传入新的参数
self.name = name
def sayHello(self):
print("hello world")
def getName(self):
return self.name
f = Female("zhangdong",44,"F","chinese")
print("your name is " + f.getName())
print(f.sayHello())
多重继承
class ClassA():
pass
class ClassB():
pass
class ClassX(ClassA,ClassB):
def __init__(self):
pass
def getName(self):
print("multi inheritance ")
x = ClassX()
print(x.getName())
析构函数
class Animal(object):
"this is a test class"
num = 0 // 类的静态成员
def __init__(self,gender,age):
Animal.num += 1
self.gender = gender
self.age = age
print("刚刚又生成了一个Animal 实例，实例的总个数为",str(Animal.num))
def __del__(self): // del一个实例的时候会执行这个函数
"打印出Animal实例的个数，执行到这里会删除Animal实例"
Animal.num -= 1
print("当前还有animal个实例个数为",str(Animal.num))
an1 = Animal("Male",20) //刚刚又生成了一个Animal 实例，实例的总个数为 1
an2 = Animal("Male",21) //刚刚又生成了一个Animal 实例，实例的总个数为 2
del an2 //当前还有animal实例的个数为1
print(an1.gender) //Male
在程序运行期间给一个class动态的添加 成员方法或者成员变量
Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性个数
class Animal(object):
"this is a test class"
num = 0
__slot__ = ("big","little")
def __init__(self,gender,age):
Animal.num += 1
self.gender = gender
self.age = age
print("刚刚又生成了一个Animal 实例，实例的总个数为",str(Animal.num))
def __del__(self):
"打印出Animal实例的个数，执行到这里会删除Animal实例"
Animal.num -= 1
print("当前还有animal个实例个数为",str(Animal.num))
an1 = Animal("Male",20)
an1.big = "it's big"
an1.little = 10000
print(an1.big) //能打印出来
使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
除非在子类中也定义__slots__，这样，子类实例允许定义的属性就是自身的__slots__加上父类的__slots__。
帮助类全局方法
type(obj) //输出类型 <class 'int'> 是个字符串
isinstance(obj,list) // 返回 True False
dir(instance) //返回一个数组list 列出全部的成员函数 和 数据成员
['__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'gender', 'num']
len() 输出 字符串，list， tuple, dict 的长度 ; len() 实际上是去调用 这个类的 __len__方法
len("abc") //3
len((1,2,3,4)) //4
len([1,2,3,4,5]) //5
len({"a":1,"b":2,True:3}) //3
"STR".lower() //字符串输出小写
getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态
hasattr(obj, 'x') # 有属性'x'吗？ // True ,False
setattr(obj, 'y', 19) # 设置一个属性'y'
getattr(obj, 'z') # 获取属性'z' //返回这个 obj.z 的值
{"a":1,"b":2}.keys() //dict_keys(['a', 'b'])
globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字
如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字
reload(模块名)
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次
因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。
异常机制处理机制 try...except...finally...
try:
print('try...')
r = 10 / 0
print('result:', r)
except ZeroDivisionError as e:
print('except:', e)
finally:
print('finally...')
print('END')
module
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
当python语句遇到import module_name 时，会先尝试从当前目录下找，然会去PYTHONPATH 环境变量指定的路径下去找 ;
事实上，模块搜索是在保存在sys.path这个全局变量中的目录列表中进行搜索
module.py
def sayHello():
print("hello world")
main.py （最上面两句话，建议写）
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import moduel
print(moduel.sayHello()) // hello world
可以一次引入多个module
import module1[, module2[,... moduleN]
from…import 语句
from 语句让你从模块中导入一个指定的部分到当前命名空间中
from modname import name1[, name2[, ... nameN]]
from fib import fibonacci // 导入模块 fib 的 fibonacci 函数 ; 多个函数用 ， 分割
// 直接执行 fibonacci() 运行这个函数
package
package是module的集合，每一个Package的根目录下面都应当有一个__init__.py 文件
当解释器发现目录下有这个__init__.py文件时，他就会认为这是一个Package，而不是一个普通的目录。
1，__init__.py是一个空白文件的方式
business 目录下有三个文件 __init__.py , bus_module.py , bus_help.py
bus_help.py
class People():
def __init__(self):
print("init People")
def greeting(self):
print("hello this is from People")
bus_module.py
def getName():
return "zhangdong"
def getGender():
return "Male"
入口文件 index.py
import business.bus_help
import business.bus_module as common
peo = business.bus_help.People() //init people
print(common.getGender()) // male
print(common.getName()) // zhangdong
2,如果在__init__.py中写入导入模块的语句
from business.bus_help import People
from business.bus_module import *
入口程序 index.py
import business //程序执行到这，会去business包里面读取__init__.py文件，这个文件已经合并了多个module
if __name__ == "__main__":
p1 = business.People()
print(business.getName())
print(business.getGender())