python3基础

注释

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()