- python的应用场景
- web应用开发
- 操作系统管理.服务器的运维自动化脚本
- 科学计算
- 桌面软件
- 服务器软件
- 游戏
注释
python的单行注释 :# python的多行的注释 : """ """
变量
# 程序用来处理数据的,而且就是用来存储数据 name = 100
标识符和关键字
标识符:由字母.下划线.和数字.而且不能开头 关键字:具有特殊功能的标识符,如:and as 命名规则: 小驼峰:第一个单词以小字母开始,第二个单词用大写 大驼峰:每个单词都是大写字母
输出
print("我是输出哦")
输入
name = input("我是输入哦")
常用格式化符号
%s :通过str()字符串来格式化 %d :整数 %f :浮点实数 %c :字符 %i :有符号的十进制 %u :无符号的十进制 %o :八进制 %X :十六进制(大写字母) %G : %f和%E的简写 %E :索引符号(大写“E”) %e :索引符号(小写'e')
运算符
+:加 两个对象相加 a + b 输出结果 30
-:减 得到负数或是一个数减去另一个数 a - b 输出结果 -10
*:乘 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/:除 x除以y b / a 输出结果 2
//:取整除 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%:取余 返回除法的余数 b % a 输出结果 0
**:幂 返回x的y次幂 a**b 为10的20次方
复合运算符
+=:加法赋值运算符 c += a 等效于 c = c + a -=:减法赋值运算符 c -= a 等效于 c = c - a *=:乘法赋值运算符 c *= a 等效于 c = c * a /=:除法赋值运算符 c /= a 等效于 c = c / a %=:取模赋值运算符 c %= a 等效于 c = c % a **=:幂赋值运算符 c **= a 等效于 c = c ** a //=:取整除赋值运算符 c //= a 等效于 c = c // a
比较运算符
== :检查两个操作数的值是否相等,如果是则条件变为真。 != :检查两个操作数的值是否相等,如果值不相等,则条件变为真。 <> :检查两个操作数的值是否相等,如果值不相等,则条件变为真。 > :检查左操作数的值是否大于右操作数的值,如果是,则条件成立。 < :检查左操作数的值是否小于右操作数的值,如果是,则条件成立。 >= :检查左操作数的值是否大于或等于右操作数的值,如果是,则条件成立。 <= :检查左操作数的值是否小于或等于右操作数的值,如果是,则条件成立。
逻辑运算符
and : x and y 布尔"与" - 如果 x 为 False,x and y 返回 False or : x or y 布尔"或" - 如果 x 是 True,它返回 True not : not x 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False
数据类型的转换
int(x [,base ]) :将x转换为一个整数
long(x [,base ]) :将x转换为一个长整数
float(x ) :将x转换到一个浮点数
complex(real [,imag ]) : 创建一个复数
str(x ) :将对象 x 转换为字符串
repr(x ) :将对象 x 转换为表达式字符串
eval(str ) :用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s ) :将序列 s 转换为一个元组
list(s ) :将序列 s 转换为一个列表
chr(x ) :将一个整数转换为一个字符
unichr(x ) :将一个整数转换为Unicode字符
ord(x ) :将一个字符转换为它的整数值
hex(x ) :将一个整数转换为一个十六进制字符串
oct(x ) :将一个整数转换为一个八进制字符串
循环的使用
n = input("请输入你要选择的数字") if n== "4": print("今天是星期四") else: print("今天不是星期四")
while循环嵌套的使用
# 九九乘法表 i = 1 while i<=9: j=1 while j<=i: print("%d*%d=%-2d "%(j,i,i*j),end='') j+=1 print('\n') i+=1
break和continue的使用
# break/continue只能用在循环中,除此以外不能单独使用 # break 用来结束整个循环 n = 1 i =1 while i < 10: n += i i += 1 if i == 3: break print(n) # 输出结果 4 # continue 用来结束本次循环,紧接着执行下一次的循环 a = 1 b = 1 while a < 10: b += a a += 1 if a == 3: continue print(b) # 输出结果 46
字符串的切片
name = 'shendinggai' # 左闭右开 步长默认为1 print(name[1:3]) # 结果为:he print(name[0:len(name)]) # 结果为:shendinggai print(name[1:-1]) # 结果为:hendingga print(name[::-2]) # 结果为:igndes print(name[::-1]) # 结果为:iaggnidnehs
字符串的常见操作
# find 的使用 异常返回-1 mystr = 'hello python hello pythonWorld' print(mystr.find("python", 0, len(mystr))) # 结果为:6 # index 的使用 异常会报错 print(mystr.index("python", 0, len(mystr))) # 结果为:6 # count 的使用 计算个数 print(mystr.count("python", 0, len(mystr))) # 结果为:2 # replace中的替换 print(mystr.replace("python", "shendinggai", mystr.count("itcast"))) # 结果为:hello python hello pythonWorld # split 为分割 后面带分割数量 print(mystr.split(" ", 9)) # 结果为:['hello', 'python', 'hello', 'pythonWorld'] # capitalize 把字符串的第一个字符大写 print(mystr.capitalize()) # 结果为:Hello python hello pythonworld # title 把每个首字母大写 print(mystr.title()) # 结果为:Hello Python Hello Pythonworld # startwith 检查是否以hello开头,返回bool值 print(mystr.startswith("hello")) # 结果为:True # endswith 检查是否以world结束 print(mystr.endswith("world")) # 结果为:False # mystr中的所有大写转换为小写字符 print(mystr.lower()) # 结果为:hello python hello pythonworld # upper 转换mystr的小写字母为大写 print(mystr.upper()) # 结果为:HELLO PYTHON HELLO PYTHONWORLD # ljust 返回一个原字符左对齐,并且使用空格填充长度with的新字符串 print(mystr.ljust(50)) # 结果为:hello python hello pythonWorld " # rjust 返回一个字符串右对齐,并使用with来填充字符串的长度 print(mystr.rjust(50)) # 结果为:" hello python hello pythonWorld # lstrip 删除mystr左边的空白 print(mystr.lstrip()) # 结果为:hello python hello pythonWorld # rsrtip 删除字符串右边的空白符号 print(mystr.rstrip()) # 结果为:hello python hello pythonWorld # strip 删除mystr字符串两边的空白符号 print(mystr.strip()) # 结果为:hello python hello pythonWorld # rfind 类似find 只是从右边开始查找 print(mystr.rfind("python")) # 结果为:19 # rindex 类似index不过从右边开始查找 print(mystr.rindex("python")) # 结果为:19 # partition 以 itcast分割成三分 print(mystr.partition('python')) # 结果为:('hello ', 'python', ' hello pythonWorld') # rpartition 以 itcast 分割成三分 右边开始寻找分割的字符串 print(mystr.rpartition("python")) # 结果为:('hello python hello ', 'python', 'World') # splitlines 按照行进行分割 就是\n 进行分割 返回一个列表 print(mystr.splitlines()) # 结果为:['hello python hello pythonWorld'] # isalpha 如果mystr所有的字符都是字母就返回True print(mystr.isalpha()) # mystr里面有空格 # 结果为:False # isdigit 如果包含数字就为True print(mystr.isdigit()) # 结果为:False # isalnum 所有字符都是字母或者数字则返回True print(mystr.isalnum()) # 结果为:False # isspace 如果mystr中只包含空格,则返回True 否则返回Flase print(mystr.isspace()) # 结果为:False # join 在列表的每个字符后面插入新的字符 ,形成新的字符 name = "_" print(name.join(mystr)) # 结果为:h_e_l_l_o_ _p_y_t_h_o_n_ _h_e_l_l_o_ _p_y_t_h_o_n_W_o_r_l_d
列表的遍历
# for循环遍历
name = ['xiaoWang','xiaoZhang','xiaoHua'] for i in name: print(i)
# while循环遍历
name = ["shen", "xiao", "gai"] length = len(name) i = 0 while i < length: print(name) i += 1
列表的添加
# 列表的添加 append name = ["hello", "world", "python"] name.append("shen") print(name) # 结果是:['hello', 'world', 'python', 'shen']
# 列表的extend的添加 name = ["hello", "world", "python"] a = ["sex", "age"] name.extend(a) print(name) # 结果为:['hello', 'world', 'python', 'sex', 'age']
列表的插入
# 列表的插入insert(index, object) index:插入的位置,object:插入的元素 name = ["hello", "world", "python"] b = "wo_shi_b" name.insert(0, b) print(name)
# 结果为:['wo_shi_b', 'hello', 'world', 'python']
列表的修改
# 列表的修改元素 直接根据下标进行修改 name = ["hello", "world", "python"] name[0] = "age" print(name) # 结果为:['age', 'world', 'python']
列表的删除
# del 根据下标删除 pop:删除最后一个元素 remove:根据元素进行删除 name = ["hello", "world", "python"] del name[0] print(name)
# 结果为:['world', 'python']
# pop从右边开始删除 name = ["hello", "world", "python"] name.pop() print(name) # 结果为:['hello', 'world']
# remove 根据值进行删除 name = ["hello", "world", "python"] name.remove("hello") print(name) # 结果为:['world', 'python']
列表的排序
# 按照字母进行排序 name = ["hello", "world", "python"] name.sort() print(name) # 结果为:['hello', 'python', 'world'] # 列表的排序 sort reverse sort 默认从小到大 reverse = True 大到小 name.sort(reverse=True) print(name) # 结果为:['world', 'python', 'hello']
元组的常见操作
# 元组不能被修改,元组使用的是小括号 name = ("hello", "world", "python") # 访问元组元素根据下表进行访问 print(name[1]) # 结果为:world print(name.count("hello")) # 元组里面的hello个数 # 结果为:1 print(name.index("world")) # 元组里面的world个数 # 结果为:1
无序集合
# 无序集合 set1 = {2,3,5,7,2} print(set1)
# 结果为:{2, 3, 4, 5, 7}
字典的常见操作
# 字典用大括号表示 有健值对 name = {"name": "shen", "age": 18, "love": "学习"} # 根据健访问值 健不存在会报错 print(name["name"]) # 结果为:shen print(name["age"]) # 结果为:18
字典的修改和增加
# 字典的修改元素和列表的差不多, 有健值就修改,没有健值就添加 name = {"name": "shen", "age": 18, "love": "学习"} name["name"] = "zhang" print(name) # 结果为: {'name': 'zhang', 'age': 18, 'love': '学习'}
字典的删除
# 删除元素 del 字典是无序的 name = {"name": "shen", "age": 18, "love": "学习"} del name["name"] # 删除一个name这个健值对 print(name) # 结果为: {'love': '学习', 'age': 18}
字典的遍历
# 字典的遍历 for i in name.keys(): # 遍历键 print(i) for i in name.values(): # 遍历值 print(i) for i in name.items(): # 遍历键值对 print(i)
全局变量和局部变量
全局变量:作用在全局的变量
局部变量:只能作用在局部的变量 用global声明
带有返回值的函数
def get_wendu(a): wendu = 22 print("当前的室温是:%d"%wendu) return wendu def get_wendu_huashi(wendu): print("------4------") wendu = wendu + 3 print("------5------") print("当前的温度(华氏)是:%d"%wendu) print("------6------") print("------1------") result = get_wendu(1000000) print("------2------") get_wendu_huashi(result) print("------3------")
带有参数的函数
#定义了一个函数 def sum_2_nums(a, b): #a = 10 #b = 20 result = a+b print("%d+%d=%d"%(a,b,result)) num1 = int(input("请输入第1个数字:")) num2 = int(input("请输入第2个数字:")) #调用函数 sum_2_nums(num1, num2)
函数的嵌套调用
def sum_3_nums(a, b, c): result = a+b+c #print("%d+%d+%d=%d"%(a,b,c,result)) return result def average_3_nums(a1, a2, a3): result = sum_3_nums(a1, a2, a3) result = result/3 #result/=3 print("平均值是:%d"%result) #1. 获取3个数值 num1 = int(input("第1个值:")) num2 = int(input("第2个值:")) num3 = int(input("第3个值:")) #sum_3_nums(num1, num2, num3) average_3_nums(num1, num2, num3)
缺省参数
def test(a,d,b=22,c=33): print(a) print(b) print(c) print(d) test(d=11,a=22,c=44)
不定长参数
def sum_2_nums(a,b,*args): print("-"*30) print(a) print(b) print(args) result = a+b for num in args: result+=num print("result=%d"%result) sum_2_nums(11,22,33,44,55,66,77) sum_2_nums(11,22,33) sum_2_nums(11,22) #sum_2_nums(11)#错误,因为 形参中 至少要2个实参
def test(a,b,c=33,*args,**kwargs):#在定义的时候 *,**用来表示后面的变量有特殊功能 print(a) print(b) print(c) print(args) print(kwargs) #test(11,22,33,44,55,66,77,task=99,done=89) A = (44,55,66) B = {"name":"laowang","age":18} test(11,22,33,*A,**B)#在实参中*,**表示对元祖/字典进行拆包
递归函数
def getNums(num): if num>1: return num * getNums(num-1) else: return num result = getNums(4) print(result)
# 结果为:24
面向对象
__init__()方法
class Cat:
"""定义了一个Cat类"""
#初始化对象
def __init__(self, new_name, new_age):
self.name = new_name
self.age = new_age
#方法
def eat(self):
print("猫在吃鱼....")
def drink(self):
print("猫正在喝kele.....")
def introduce(self):
print("%s的年龄是:%d"%(self.name, self.age))
#创建一个对象
tom = Cat("汤姆", 40)
tom.eat()
tom.drink()
#tom.name = "汤姆"
#tom.age = 40
tom.introduce()
lanmao = Cat("蓝猫", 10)
#lanmao.name = "蓝猫"
#lanmao.age = 10
lanmao.introduce()
# 结果是:
"""
猫在吃鱼....
猫正在喝kele.....
汤姆的年龄是:40
蓝猫的年龄是:10
"""
__str__方法
class Cat: """定义了一个Cat类""" #初始化对象 def __init__(self, new_name, new_age): self.name = new_name self.age = new_age def __str__(self): return "%s的年龄是:%d"%(self.name, self.age) #方法 def eat(self): print("猫在吃鱼....") def drink(self): print("猫正在喝kele.....") def introduce(self): print("%s的年龄是:%d"%(self.name, self.age)) #创建一个对象 tom = Cat("汤姆", 40) lanmao = Cat("蓝猫", 10) print(tom) print(lanmao)
私有方法
class Dog: #私有方法 def __send_msg(self): print("------正在发送短信------") #公有方法 def send_msg(self, new_money): if new_money>10000: self.__send_msg() else: print("余额不足,请先充值 再发送短信") dog = Dog() dog.send_msg(100)
# 结果为:余额不足,请先充值 再发送短信
__del__()方法
class Dog: def __del__(self): print("-----英雄over------") dog1 = Dog() dog2 = dog1 del dog1 # 不会调用 __del__方法,因为这个对象 还有其他的变量指向它,即 引用计算不是0 del dog2 # 此时会调用__del__方法,因为没有变量指向它了 print("====================") # 如果在程序结束时,有些对象还存在,那么python解释器会自动调用它们的__del__方法来完成清理工作
# 结果为:
-----英雄over------
====================
继承
class Animal: def eat(self): print("-----吃----") def drink(self): print("-----喝----") def sleep(self): print("-----睡觉----") def run(self): print("-----跑----") class Dog(Animal): def bark(self): print("----汪汪叫---") class Xiaotq(Dog): def fly(self): print("----飞----") xiaotq = Xiaotq() xiaotq.fly() xiaotq.bark() xiaotq.eat()
# 结果为:
----飞----
----汪汪叫---
-----吃----
多继承
class Base(object): def test(self): print("----Base") class A(Base): def test(self): print("-----A") class B(Base): def test(self): print("-----B") class C(A,B): def test(self): print("-----C") c = C() c.test() print(C.__mro__) # 结果为:-----C (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>)
多态
class Dog(object): def print_self(self): print("大家好,我是xxxx,希望以后大家多多关照....") class Xiaotq(Dog): def print_self(self): print("hello everybody, 我是你们的老大,我是xxxx") def introduce(temp): temp.print_self() dog1 = Dog() dog2 = Xiaotq() introduce(dog1) introduce(dog2) """ 多态: 1.要发生继承 2.要重写父类方法 3.调用重写的方法 """
鸭子类型
""" 面向对象语言三大特性: 1.封装: 对象的数据和行为 以属性和方法的形式定义类的里面 2.继承: 想要拥有另一个类的属性和方法 3.多态: 在用父类对象的地方,用了子类的对象 鸭子类形: 并不强求对象/数据的类型,只要对象/数据能完成指定的操作,不报错就可以, 动态类型语言的特性 """ class Meat: """肉类""" def __init__(self): self.name = "肉" class Ham(Meat): """火腿类""" def __init__(self): super().__init__() self.name = "火腿" class SweetPotato: """地瓜""" def __init__(self): self.name = "地瓜" pass class Person: """人类""" def eat(self, meat): print("我要吃%s" % meat.name) m1 = Meat() h1 = Ham() digua = SweetPotato() p1 = Person() # p1.eat(m1) # p1.eat(h1) p1.eat(h1)
# 结果为:我要吃火腿
实例方法,类方法,静态方法
class Game(object): #类属性 num = 0 #实例方法 def __init__(self): #实例属性 self.name = "laowang" #类方法 @classmethod def add_num(cls): cls.num = 100 #静态方法 @staticmethod def print_menu(): print("----------------------") print(" 穿越火线V11.1") print(" 1. 开始游戏") print(" 2. 结束游戏") print("----------------------") game = Game() #Game.add_num()#可以通过类的名字调用类方法 game.add_num()#还可以通过这个类创建出来的对象 去调用这个类方法 print(Game.num) #Game.print_menu()#通过类 去调用静态方法 game.print_menu()#通过实例对象 去调用静态方法
# 结果为
100
----------------------
穿越火线V11.1
1. 开始游戏
2. 结束游戏
----------------------
单列模式
class Dog(object): __instance = None def __new__(cls): if cls.__instance == None: cls.__instance = object.__new__(cls) return cls.__instance else: #return 上一次创建的对象的引用 return cls.__instance a = Dog() print(id(a)) b = Dog() print(id(b)) # 结果为: 140278199835112 140278199835112
只初始一次
class Dog(object): __instance = None __init_flag = False def __new__(cls, name): if cls.__instance == None: cls.__instance = object.__new__(cls) return cls.__instance else: #return 上一次创建的对象的引用 return cls.__instance def __init__(self, name): if Dog.__init_flag == False: self.name = name Dog.__init_flag = True a = Dog("旺财") print(id(a)) print(a.name) b = Dog("哮天犬") print(id(b)) print(b.name) # 结果为: 140432460909144 旺财 140432460909144 旺财
异常
try: # 尝试 如果程序出现错误,它不会直接崩溃,而是执行except里面的代码,然后后续代码依然可以正常执行 path = input("请输入要读取的文件:") f = open(path) content = f.read() f.close() # print(a) except FileNotFoundError as error: # 只拦截文件未找到的错误 # 当try里面的代码出现错误,就会自动执行except 来捕获异常,如果try里面代码没有出错就不会执行except中的代码 print("文件没找到 %s" % error) except NameError as error: # 只能拦截变量未定义类型错误 print("变量未定义 %s" % error) except: print("所有异常都会捕获") else: # 当try里面的代码没有错误时会执行,else要写在finally的前面 print("当try里面的代码没有出错时就会执行") finally: print("无论有没有错误最终都会执行finally里面的代码") # try在使用时,必须后面要跟一个except或finally,else可跟可不跟 # 异常是分类型的 # BaseException 是所有异常类的基类 print("后续的功能")
自定义异常
# try: # # print(b) # # 当出现异常会自动创建一个异常对象并抛出 # raise NameError() # 手动抛出异常 # except NameError as error: # print("%s" % error) class CustomException(Exception): # 自定义异常类必须要继承到Exception # def __init__(self, info): # self.info = info # # def __str__(self): # print("----") # return "%s" % self.info pass # 自定义异常就是会了 简化异常 phone_num = input("请输入电话号:") try: if len(phone_num) != 11: # print("手机位数不对") raise CustomException("手机位数不对") elif phone_num.isdecimal() is False: # 判断是不是纯数字的字符串 # print("手机号码,输入不合法") raise CustomException("手机号码,输入不合法") except CustomException as error: print("提示:%s" % error) # 弹出提示框显示错误信息
匿名函数
infors = [{"name":"laowang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":10}] infors.sort(key=lambda x:x['age']) print(infors)
# 结果为:
[{'name': 'laowang', 'age': 10}, {'name': 'banzhang', 'age': 10}, {'name': 'xiaoming', 'age': 20}]
文件操作
f = open("xxx.txt","r") content = f.read() print(content) f.close() # 第二种方式 name = input("") with open("123.txt", "w") as f: f.write(name)
is 和==
list1 = [1, 2] list2 = list1 # == 比较两边变量中保存的值 # if list1 == list2: # print("相等") # is 判断两边变量的引用地址是否相同 if list1 is list2: print("相等") else: print("不等") # 一般比较两个变量的值是否一样都应该用 == # 如果比较一个变量/属性是不是为 None False True 等等尽量用is 性能会好点
# 结果为:相等
导入模块
# 模块的导入方式 import sys from sys import path # 单独把模块拷贝出来,不是引用
推导式
# 列表推导式 # list1 = [i**2 for i in range(1, 11) if i % 2 == 0] # 字典推导式 # dict2 = {dict1[key]: key for key in dict1} #匿名函数 # res = (lambda num1, num2: num1 + num2)(1, 2)