注释
python中使用‘#’注释一行代码，多行注释使用""" """
#这是一个注释
"""
这里的内容被注释掉了
"""
print("hello world")
格式化输出
%s 格式化的内容是字符串类型 ，%.f格式化 的内容是浮点类型 %d格式化内容为数字%%格式化输出特殊字符‘%’（转义）
name="feng"
print("我的名字叫：%s" % name)
stu_no = 106
print("我的号码是： %06d" % stu_no) #000106不足6位前面补0
#输出百分比
progress = 0.8
print("占比例为 %.2f%%" % (progress*100))
#格式化输出小数
price = 1.25
weight=2.25
totalprice = price * weight
print("单价 %.2f 重量 %.3f 总价 %.4f" % (price,weight,totalprice))
逻辑运算 if else
num =80
if num > 80:
print("优秀")
elif num >=60 and num <=80:
print("及格")
elif num >=0 and num <60:
print("不及格")
else:
print("...")
sex = '男'
if sex == '男' or sex =='女':
print("性别正常")
else:
print("性别错误")
循环
i = 10
while i<=10:
print("hello")
if i == 6:
break #跳出循环 continue 继续循环
i+=1
#打印小星星
row = 1
while row <=10:
col = 1
while col <=row:
print("*",end="")
col +=1
row+=1
print("") #换行
"""
打印剩法表
1 * 1 = 1
1 * 2 = 2 2 * 1 = 2
1 * 3 = 3 2 * 2 = 4
... ...
1 * 9 = 9 2 * 9 = 18 9 * 9 = 81
分析 ： 共有9行，没行输出的列数与行号一样
"""
row = 1 #行数
while row <= 9:
col = 1 #列数
while col <= row:
print("%d * %d = %d" % (row,col,row*col),end="\t") #\t表示输出的时候垂直方向对齐
col +=1
row+=1
print("")
函数
定义函数使用关键字def 如 def test(): 定义名为test的函数,
def test():
print("test")
列表
name_list = ["a","b","c"]声明一个列表
name_list.index(val)找出传递内容在列表的位置
name_list.append(val)列表追加数据
name_list.insert(1,val)指定位置插入数据
name_list.extend(['d'])合并列表
name_list.remove(val)从列表中删除指定内容(只会删除第一次出现的)
name_list.pop(index) 删除列表最后一个元素/删除指定位置的元素
name_list.clear()清空列表
name_list.count(val) 查找内容在列表中出现的次数
name_list.reverse()反转列表
len(name_list) 计算列表的长度
gl_list = [6, 3, 9]
# 默认按照升序排序 - 可能会多！
# gl_list.sort()
# 如果需要降序排序，需要执行reverse参数
gl_list.sort(reverse=True)
#遍历列表
for name in name_list:
print(name)
元组
a = (1,2,3)定义一个元组
元祖定义之后不可改变，其他的函数使用方法跟列表相似
字典
字典其实是php/js中的json格式的数据
m_dict = {"name":"feng","age":24,"heght":"174cm"}
print(m_dict['name'])
len(m_dict) 统计字典的key数量
m_dict.update({"name":feng}) 合并字典同key会被覆盖
m_dict.clear()清空字典
#遍历字典
for k in m_dict:
print(m_dict[k])
字符串
str = "hello world"
len(str) 获取字符串的长度
str.count(val)获取内容出现在字符串的次数
str.index(val)某个字符出现在字符串的位置，如果不存在报错
str.find(val)查找目标字符串的位置，不存在返回-1
str.replace("world","python")字符串替换 不会修改原有的字符串
str.strip()去除空白字符
str.split() 拆分字符串
" ".join(str) 合并字符串
关键字
del 删除 ，del name 从内存中删除name变量
可变参数与不可变参数
在函数外部定义的变量，在函数内部是否能进行修改
def demo(num, num_list):
print("函数内部的代码")
# 在函数内部，针对参数使用赋值语句，不会修改到外部的实参变量
num = 100
num_list = [1, 2, 3]
print(num)
print(num_list)
print("函数执行完成")
gl_num = 99
gl_list = [4, 5, 6]
demo(gl_num, gl_list)
print(gl_num) #99
print(gl_list) #[4,5,6]
def demo(num_list):
print("函数内部的代码")
# 使用方法修改列表的内容
num_list.append(9)
print(num_list)
print("函数执行完成")
gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list) #1,2,3,9
结论:python 中列表是可变参数，字符串，数字类型变量是不可变参数
多值参数
*nums 表示传进的参数例如：num 单个／多个这种形式的 函数内部会转为元组
**person 表示传进的参数是：k=v 这种形式的 函数内部会转为字典
def demo(num, *nums, **person):
print(num)
print(nums)
print(person)
# demo(1)
demo(1, 2, 3, 4, 5, name="小明", age=18)
面向对象
1.self就是实例化对像的引用
2.实例化对象不需要使用关键字 new
3.设置对象属性直接 obj.属性 = 值 即可
4.私有属性 self.__age = 18 (在名称前面加__)
5.继承 class Dog(Animal): class 类名(父类名)：
6.子类调用父类方法:super().方法名() / 父类名.方法(self)
7.多继承 class C(B, A): print(C.__mro__)# 确定C类对象调用方法的顺序
class A:
def test(self):
print("A --- test 方法")
def demo(self):
print("A --- demo 方法")
class B:
def test(self):
print("B --- test 方法")
def demo(self):
print("B --- demo 方法")
class C(B, A):
"""多继承可以让子类对象，同时具有多个父类的属性和方法"""
pass
# 创建子类对象
c = C()
c.test()
c.demo()
# 确定C类对象调用方法的顺序
print(C.__mro__)
class Cat:
def eat(self):
# 哪一个对象调用的方法，self就是哪一个对象的引用
print("%s 爱吃鱼" % self.name)
def drink(self):
print("%s 要喝水" % self.name)
# 创建猫对象
tom = Cat()
# 可以使用 .属性名 利用赋值语句就可以了
tom.name = "Tom"
tom.eat()
tom.drink()
tom.name = "Tom"
#初始化函数
def __init__(self, new_name):
print("这是初始化函数")
self.name = new_name
#析构函数
def __del__(self):
pass
#输出字符串
def __str__(self):
# 必须返回一个字符串
return "我是小猫[%s]" % self.name
8.类的属性
class Tool(object):
# 使用赋值语句定义类属性，记录所有工具对象的数量
count = 0
def __init__(self, name):
self.name = name
# 让类属性的值+1
Tool.count += 1
# 1. 创建工具对象
tool1 = Tool("斧头")
tool2 = Tool("榔头")
tool3 = Tool("水桶")
# 2. 输出工具对象的总数
print(Tool.count) # 3
@classmethod 与@staticmethod
classmethod：如果我们想通过类来调用方法，而不是通过实例 ，就可以通过classmethod来修饰方法 参数cls，代表类本身
class cat(object):
word = 'hello'
@classmethod
def say(cls):
print("他说 %s" % cls.word)
cat.say()
静态方法 通过staticmethod来修饰,静态方法没有 self 和 cls 参数，可以把它看成是一个普通的函数
class Dog(object):
@staticmethod
def run():
# 不访问实例属性/类属性
print("小狗要跑...")
# 通过类名.调用静态方法 - 不需要创建对象
Dog.run()
__new__ 方法
class MusicPlayer(object):
def __init__(self):
print("播放器初始化")
def __new__(cls, *args, **kwargs):
# 1. 创建对象时，new方法会被自动调用
print("创建对象，分配空间")
# 2. 为对象分配空间
instance = super().__new__(cls)
# 3. 返回对象的引用
return instance
# 创建播放器对象
player = MusicPlayer()
print(player)
单例
class MusicPlayer(object):
# 记录第一个被创建对象的引用
instance = None
def __new__(cls, *args, **kwargs):
# 1. 判断类属性是否是空对象
if cls.instance is None:
# 2. 调用父类的方法，为第一个对象分配空间
cls.instance = super().__new__(cls)
# 3. 返回类属性保存的对象引用
return cls.instance
# 创建多个对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)
异常
try:
# 提示用户输入一个整数
num = int(input("输入一个整数："))
# 使用 8 除以用户输入的整数并且输出
result = 8 / num
print(result)
except ValueError:
print("请输入正确的整数")
except Exception as result:
print("未知错误 %s" % result)
else:
print("尝试成功")
finally:
print("无论是否出现错误都会执行的代码")
print("-" * 50)
模块
import hm_01_测试模块1 as DogModule
import hm_02_测试模块2 as CatModule
DogModule.say_hello()
CatModule.say_hello()
dog = DogModule.Dog()
print(dog)
cat = CatModule.Cat()
print(cat)
# 如果直接执行模块，__main__
if __name__ == "__main__": #判断是否是cli下执行的
print(__name__)
文件操作
# 1. 打开
file_read = open("README")
file_write = open("REAMDE[复件]", "w")
# 2. 读、写
while True:
# 读取一行内容
text = file_read.readline()
# 判断是否读取到内容
if not text:
break
file_write.write(text)
# 3. 关闭
file_read.close()
file_write.close()
