(一)前言:
1. IDLE:python学习的外壳,即通过键入文本与程序交互的途径。、
2. 在python官网下载python到本地,在电脑左下角开始->搜索找到IDLE打开,即可看到编译软件。
3. 基础:print("welcome python") ,表示打印输出里面的语句,主要python3.0之后不支持print "welcome python"和 printf("welcome python"); 2种写法都不支持,报错。 #在python中表示注释。dir(_bulitins_)查看python的内置函数(bif),help(big)查看某个内置函数的解释说明,type(a)查看a的类型,isinstance(a,str/int/float)判断a的类型是否是字符串/整数/浮点型,返回true/false。ctrl+n进入IDLE的编译入口,即之编译不执行,再保存后按F5或者点击run即可执行编译好的代码块。alt+n下一条编译语句,alt+p上一条编译语句。
,
(二)基础语法:
1. python支持的数据类型:Number(数字,包括整型int,浮点型float,复数complex),String(字符串),List(列表),Tuple(元组),Sets(集合),Dictionary(字典);
2.整型int:包括正,负整数,没有限制大小,支持+、-、*、/法则。注意:在整数除法中,(/)计算的结果是浮点数(即使能整除也至少保留一位小数)如151/51 结果为3.0,(//)表示只取结果的整数部分,如200//51 结果为3。
3. 浮点型float:有小数点,或者科学计数法表示。支持+、-、*、/法则。注意:在计算机中整型和浮点型存储方式不同,整数的运算永远是精确的,浮点型运算可能会有四舍五入的误差,如3.3*102 结果为352.0999999999997,且浮点型在四则运算下结果都为浮点型。
4. 复数complex:即有实数部分和虚数部分组成,a+bj或complex(a,b)表示复数,其中a、b都是浮点型。
5. 数据类型的转换:int(x) :x转换为整数,即去整数部分,单是只能转换数值类型或者纯数字的字符串类型,否则报错。float(x):x转换为浮点型。complex(x):x转换为复数,实数部分x,虚数0。complex(x,y):x为实数部分,y为虚数部分。str(x):x转换为字符串,str(5e10) 其结果为"5e10"。
6. 常量:全部大写的变量名,如PT(圆周率)和E(自然常数)。
7. 转义:转移字符\或者在字符串前加r'这是字符串,里面的特殊符号会被转义'。注意用r转义时,字符串最后一位不能是\。对于很多行的字符串,需要用三引号""",如""" 这里是一段小诗 """ 。注意:单双引号都是英文的。
8. 模块: import random, 引用random模块, random.randint(1,10)调用random模块中的randint()方法,随机生成1~10的整数。
9. 算术操作符:+、-、*、/、%、**(幂运算)、//(除取下整)。
10.比较操作符:>、<、>=、<=、==、!=。
11.赋值运算符:=、+=、-=、*=、/=、%=,**=、//=。
12.位运算符:&、|、^、~、<<、>>。
13.逻辑操作符:and 、or、not。
14.成员运算符:in、not in。
15.身份运算符:is、is not。
16.优先级:幂运算>正负符号>算术运算符>比较运算符>逻辑运算符。
17. 在hbuilder编译器中怎么编译.py文件:https://blog.csdn.net/u011662047/article/details/51568911;18. 变量: 无需声明,直接赋值,全部大写字母可以表示常量也不需要声明, teacher="我是变量值,被赋值给前面的teacher变量",变量的命名,由数字,字母,_组成,数字不能再首位,且不能是关键词。在使用变量前 需要进行赋值。命名规则:驼峰命名法,匈牙利命名法,下划线命名法。注意,在使用变量之前,一定要对其赋值。
(三)列表和元祖:
1.序列:包括列表,元祖,字符串,Unicode字符串,buffer对象,xrange对象。序列的操作如下:
① 索引:即下标,通过索引获取单个元素,a[0]。正向从0开始,反向从-1开始。
② 分片:获取一定范围的元素组成的序列,a[start:end:step],含start不含end,step默认1,不位0,负数表示反向取值。
③ 序列拼接:通过'+'返回新的序列。
④ 乘以数字:序列*数字,返回,重复数字遍的新序列。如'a'*3='aaa';
⑤ 判断成员资格:in、not in。
⑥ 常用api:len(a),max(a),min(a)。
2.列表:除了以上序列的操作方法,还有如下操作:
① 元素索引赋值:通过索引修改元素的值,list[0]="修改列表下标为0的值"。但是,不能为不存在位置赋值。
② 增加元素append:list.append(obj),向列表尾部添加obj元素。
③ 删除元素del:del list[1],删除页列表指定下标对应的元素。
④ 列表化对象list():将字符串转换为列表;
⑤ 分片插入:list[2:2]="这列表2位置插入该值"。
⑥ 嵌套列表:[[1,2],3,4]。
⑦ 列表方法:
⑴ append:list.append(obj),在列表尾部添加元素。
⑵ count:list.count(obj),元素obj在列表中出现的次数。
⑶ extend:list.extend(obj),在列表尾部追加另一个序列的多个值,修改原列表。
⑷ index:list.index(obj),从列表中查找第一个匹配项obj的索引位置。
⑸ insert:list.insert(index,obj),在列表指定位置,插入指定元素。
⑹ pop:list.pop(i),移除列表中指定位置的元素,并返回该值,默认不写i,是移除最后一个元素。
⑺ remove:list.remove(obj),移除列表中第一个出现obj值的元素。
⑻ reverse:list.reverse(),列表倒叙。
⑼ sort:list.sort(func),列表排序。
⑽ clear:list.clear(),清空列表,相当于del list[:]。
⑾ copy:list.copy(),复制列表,相当于list[:]。
3.元祖:内容不能改变的列表,空元祖(),只有一个元素的元祖(1,)。
① tuple():函数是讲序列转换为元祖。
② 索引访问元祖:tuple[i],查找元祖下标i的值。
③ 拼接元素:通过'+'返回新的元祖。
④ 删除元祖:del tuple1,只能删除整个元祖,不能删除元祖里面的某个元素。
⑤ 分片元祖:tuple1[1:]。
⑥ len(tuple1):元祖长度,max/min(tuple1),元祖里最大最小值。
(四)字符串:
1.字符串:由单/双引号构成,支持序列的索引,分片,成员资格,长度,最大最小值。但是不支持分片赋值。
2.转义字符:
3.字符串格式化:使用'%'完成字符串格式化操作。
print("阿哲今年%s岁"%'27')。
print("%s今年%s岁"%("Ace",'27'))。
4.字符串的api方法:
① find():str.find(str1,start=0,end=len(str)),查找字符串str中从索引start开始到end结束的子字符串str1第一次出现的位置,找到返回该位置,找不到返回-1。不写start和end默认查找整个字符串。
② join():str.join(sq),将序列sq中的元素,通过字符str(如'+',','等)拼接成新的元素。注意,str和sq里面的元素都必须全是字符串,否则报错,即'+'.join([1,2])会报错。
③ lower():str.lower(),不需参数,将字符串str全部大写转换为小写。
④ upper():str.upper(),不需参数,将字符串str全部小写转换为大写。
⑤ swapcase():str.swapcase(),不需参数,将字符串str中小写转换为大写,小写转换为大写。
⑥ replace():str.replace(old,new[,max]),将字符串str中的old子字符串替换为new字符串,不写max参数,表示替换所有的old,有max参数表示最多替换max次old。
⑦ split():str.split(str1="",num)将字符串切片成列表,str是切割符,默认是空格,num表示切割几次,默认是该切割符
存在的次数。
⑧ strip():str.strip([chars]),去掉字符串首尾的chars字符(如'---'),默认是空格。
(五)字典:
(六)条件、循环和其他语句:
1.文件名:智能是字母,数字,下划线组成。
2.import的使用:import module1[,module2,module3] 从python标准库中引入单个或多个模块。import math as m,为模块取别名。
3.from modname import name1[,name2,name3]/*:从指定模块中引入其中的部分函数,*表示引入模块中所有。 from math import pi as p,取别名。
4.使用逗号输出:print("a","b","c")
5.赋值:
① 序列解包:如x,y,z=1,2,3,相当于x=1,y=2,z=3赋值。注意:左边的x,y,z和右边的1,2,3数量必须相等,否则报错。
② 链式赋值:如x=y=z=10。
③ 增量赋值:如*=、+=、-=、/=、//=、%=、**=。
6. 条件语句:
① if 条件表达式:
#满足条件表达式时,执行的代码,需要缩进。
elif 条件表达式:
#满足条件,执行的代码。
else:
#else执行的代码。
② 嵌套代码:即if条件语句里面还有嵌套if语句。
③ is的同一性运输符:x is y与x==y,前者是判断x和y是否指向同一内存地址,后者判断x和y值是否相等。
7. 循环:
① while 条件表达式/True:
#执行循环体
break #跳出循环
countinue #跳出当前循环进入下一次循环
② for item in seq: #循环任何序列,包括字符串,列表。for key,value in tuple1.items(): 循环字典。注意:字典是无序的。for num1,num2 in zip(range(3),range(100)),zip函数以短序列range(3)为准长度,当短序列遍历结束,for循环就会结束。num1,num2分别对应序列range(3)和range(100)的元素。
③ sorted(seq):倒序排列序列,并返回列表。如seq=[1,2,3]或seq='hello,world!'。
④ reversed(seq):倒序排列序列,并返回与原序列同类型,如字符串,列表,就返回倒序后的字符串,列表。
⑤ pass:空语句,保持程序结构的完整性。
(七)函数:
1. 对代码的封装:重用,优化代码,对有参数的函数,参数类型不对,数量不对也会报错。
2.函数的声明:
def 函数名(参数):
#要执行的函数体,必须缩进,没有return或者return(return None)表示返回值都是None。
3.函数的参数:
def fun(name,age=27):
#调用函数fun时,传入的参数方式,fun("Ace",27)或fun(name="Ace",age=27),在声明函数def fun(age=27)表示默认参 #数值为27,注意无论多少个默认参数,默认参数都不能在必须参数之前。如不能def fun(age=27,name):会报错。对 #于不确定参数个数的用*arg表示未知参数个数,对于参数是字典的未知元素个数,用**arg。组合参数顺序:def fun(p #,d val,**a)。
4.函数的执行流程:从上倒下,从左到右。
5.形参和实惨:
6.变量的作用域:局部作用域,全局作用域。
7.递归函数:函数内部调用函数自身。
8.匿名函数:调用完就在内存中清除的函数。
lambda x,y:
return x+y
(八)面向对象编程:
1.类的声明:
class MyClass(obj): #声明一个类MyClass,继承obi类对象。
n=11 #这是类变量,即实例化对象可以调用,但是不能修改的变量。可以通过MyClass.n修改其值。
def __init__(self,name,job): #声明类的静态属性,即构造函数,在实例化时初始化类的一些变量,即将变量存储。
self.name=name
self.__job=job #私有属性,和私有方法一样使用。
def __foo(): #私有方法
print("__这是类的私有方法,无法实例化类调用,只能在声明MyClass类中调用,如在func中调用")
def func(self,age): #声明类动态方法。
print("名字:%s,年龄:%s"%(self.name,age)) #age是实例化类,调用func函数传入的参数d.func(27)。
self. __foo() #仅仅在类里面调用私有方法/属性。
return
def __del__(self): #析构函数,类销毁,释放时执行的函数。
#print("类被销毁时执行该析构函数")
2. 类的实例化:
d=MyClass("Ace") #实例化类。
d.name="Alice" #修改类的静态变量。
d.func(27) #调用类的动态方法。
3.类的继承:python3的经典类和新式类都是按照广度优先继承的。
class People(object): #父类
def __init__(self,name,age):
self.Name=name
self.age=age
print("实例化类时就执行此代码!")
def eat(self):
print("%s is eating...."%self.name)
class Man(People): #子类继承父类People,
def __init__(self,name,age,money):
People.__init__(self,name,age) #旧的方式:继承父类的静态属性,一条代码只能继承一个父类
self.money=money #添加子类的静态属性
def game(self):
print("子类%s的自己的方法"%self.name)
def eat(self): #重构父类的eat方法
People.eat(self)
print("为父类的eat方法添加新功能")
class Woman(People): #子类继承父类People, 这里是多继承的话,与顺序有关。
cn="中国"
def __init__(self,name,age,money):
super(Woman,self).__init__(name,age) #新的方式:继承父类的静态属性,可以继承多个父类
self.money=money #添加子类的静态属性
def shop(self):
print("%s is shopping"%self.name)
@staticmethod #即将下面的cc函数变为静态方法,即不在与Woman类有关系了,只是单纯放在Woman类里的函数
def cc():
print("这是静态方法,不能调用Woman类里的方法和属性") #即不能在self.name/shop()了
@classmethod #即将下面的cm函数变为类方法,即其下方法只能访问类变量,不能方法实力变量(静态属性)。
def cm():
print("只能访问类变量cn,不能方法实力变量(静态属性)")
@property #即将下面的cx函数动态方法变为静态属性,即实例化对象d.cx即可调用,而不能d.cx()
def cx():
print("已经变成静态属性,只需要实例化对象d.cx即可调用,不能d.cx()调用")
4.类的多态:即父类和子类动态方法名冲突时,以子类为准,重构父类的该动态方法。
5.类的专有方法:__str__,__doc__,__iter__,__getitem__,__getattr__。
① __doc__:打印类的描述信息。
class Dog():
'''这是类的描述信息注释,可以通过Dog.__doc__打印出来该描述注释信息'''
pass
(九)异常处理:
1.异常处理:对异常可能报错的处理。
try:
#这是执行可能报错的代码。
except KeyError as e:
print("错误是:",e)
except Exception as e :
print("除了KeyError的其他异常:",e)
else:
print("没有报错异常执行该代码")
finally:
print("无论是否有异常,有会执行该代码")
2.自定义异常:
class MyException(Exception): #自定义异常,继承异常类Exception
pass
try:
raise
MyException("这是我定义的异常")
except
MyException as e:
print e