Python基础学习

1、字符串类型的变量内容有换行的时候，可以用三个单引号或者三个双引号括起来

str='''
I am a student.
Nice to meet you!
'''

print(str)

str="""
I am a student.
Nice to meet you!
"""
print(str)

 2、对字符串中的字符提取时通过索引进行提取，有两种方式

• 从前往后索引，下标从0开始
• 从后往前索引，下标从-1开始

 3、常用的字符串方法

 

star = " NEPTUNE "
#长度为9
print(len(star))
#长度为7
print(len(star.strip()))

say_hi = "Hello World!"
#输出Hello Kitty!
print(say_hi.replace("World", "Kitty"))

say_hi = "Mercury,Venus,Earth,Mars,Jupiter,Saturn,Uranus,Neptune,Pluto"
#变成了字符串数组['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto']
arr=say_hi.split(",")
print(arr)

book_name = "Men Are from Mars, Women Are from Venus"
#True
is_exist = "Mars" in book_name
#False
is_exist = "Mars" not in book_name

 4、在字符串中引用变量的值

name = 'Earth'
age = 4.543E9
#输出结果为：My name is Earth, 4543000000.0 years old
print(f"My name is {name}, {age} years old")

 5、print(f"")的使用

briage_len=0
bird_num=150000
print(f"bird_num={bird_num},briage_len={briage_len}")

 6、访问列表和访问字符串的字符一样，可以从前往后访问（下标从0开始），也可以从后往前访问（下标从-1开始）

 7、访问列表时带步长[m:n:步长]（包含m,不包含n）

 

 

 

 可以通过将步长设置为-1，来实现列表的反转

 

 8、删除列表中的元素，使用del 列表名[i]

 

 9、使用del 列表名[m:n]，删除列表中的多个元素

 

 10、往列表中添加元素，使用 列表名 += [元素1,元素2,元素3,...,元素n]

 

 11、往列表中添加元素，使用append()

 

 总结：使用+和append()都是在列表的结尾处添加元素

12、在列表的指定位置插入元素，使用insert(n, 需要添加的元素/列表值)，n 为需要插入元素或列表的指定位置

 

 13、在列表中删除指定元素，使用 remove(元素值)

 

 14、在列表中删除指定元素，使用 列表名.pop(index)，从列表中删除指定索引上的元素，如果不指定 index，默认删除最后一个元素

 

 15、从列表中删除元素有remove()和pop()，两者的区别？

a) remove()的参数是元素，pop()的参数是索引

b) remove()的返回值是None，pop()的返回值是被删除的元素

 16、break语句是结束整个循环，continue语句是结束本轮循环

17、访问字典的方式

 

只打印出来字典中的value

 

 18、删除字典的操作

zhangsan_info = {'num':1,'name':'张三','sex':'男','height':'180cm','address':'河南'}
#打印结果为{'num': 1, 'name': '张三', 'sex': '男', 'height': '180cm', 'address': '河南'}
print(zhangsan_info)
#字典名.pop(键名)
zhangsan_info.pop('num')
#打印结果为：{'name': '张三', 'sex': '男', 'height': '180cm', 'address': '河南'}
print(zhangsan_info)
#popitem()删除最后插入的项目
zhangsan_info.popitem()
#打印结果为：{'name': '张三', 'sex': '男', 'height': '180cm'}
print(zhangsan_info)
#del 字典名[键名]
del zhangsan_info['height']
#打印结果为：{'name': '张三', 'sex': '男'}
print(zhangsan_info)
#del 字典名：完全删除字典
#完全删除该字典后，zhangsan_info变量将不存在
del zhangsan_info

19、其它字典的操作

zhangsan_info = {'num':1,'name':'张三','sex':'男','height':'180cm','address':'河南'}
#复制字典：copy()
zhangsan_info_copy1=zhangsan_info.copy()
print(zhangsan_info_copy1)
#复制字典：dict()
zhangsan_info_copy2=dict(zhangsan_info)
print(zhangsan_info_copy2)
#清空字典
zhangsan_info.clear()
#打印结果为：{}
print(zhangsan_info)
#使用dict()创建字典
d=dict(num=2,name='李四',sex='男',height='175cm')
#打印结果：{'num': 2, 'name': '李四', 'sex': '男', 'height': '175cm'}
print(d)

 20、元组的定义

元组的一个特征是：元组在创建完成后便不能被修改，因此任何关于修改元组的操作都会报错

#如果需要创建一个仅包含一个元素的元组，必须在该元素后面添加一个逗号，否则，Python 无法将变量识别为元组。
loong_son1 = ('囚牛') # 不是元组,类型为str
loong_son2 = ('囚牛',)
#打印结果：<class 'str'>
print(type(loong_son1))
#打印结果：<class 'tuple'>
print(type(loong_son2))

21、访问元组的方式跟访问列表的方式一样，正负索引法、切片法、遍历法

22、合并元素：元组不能被修改，但是两个元组是可以合并成一个新的元组的，在 Python 中，使用 + 运算符可以连接两个或多个元组

loong_son1 = ('一', '二', '三')
loong_son2 = ('三','四', '五')
loong_son = loong_son1 + loong_son2
#打印结果：('一', '二', '三', '三', '四', '五')
print(loong_son)

23、集合的定义：集合是无序元素的集合，集合中的元素不可重复，如果有重复元素，重复的元素将被忽略，集合中已存在的元素不可以被修改，但是可以向集合中增加元素，也可以从中删除元素。

#往集合中添加元素
students={'zhangsan','lisi','wangwu','zhaoliu'}
#add()方法
students.add('qianqi')
students.add('qianqi')
#打印结果：5
print(len(students))
#update()方法
students.update({'qianba','qianjiu'})
students.update(['qianshi','qianshiyi'])
#打印结果：9
print(len(students))
#从集合中删除元素
#discard()方法
students.discard('qianshi')
#remove()方法
students.remove('qianba')
#打印结果：7
print(len(students))
#discard()与remove()的区别：在删除一个不存在的元素时，discard()不执行任何操作，remove()抛异常

 24、集合的运算：并、交、差

num1={1,2,3}
num2={2,3,4}
#并：union()
print(num1.union(num2))
print(num2.union(num1))
#并：集合1|集合2
print(num1|num2)
#以上输出的结果均是：{1, 2, 3, 4}

#交：集合1.intersection(集合2)
print(num1.intersection(num2))
print(num2.intersection(num1))
#交：&
print(num1&num2)
print(num2&num1)
#以上输出的结果均是：{2, 3}

#差：集合1.difference(集合2)：属于集合1 不属于集合2 
#打印结果：{1}
print(num1.difference(num2))
#打印结果：{4}
print(num2.difference(num1))
#差：集合1-集合2：属于集合1 不属于集合2 
#打印结果：{1}
print(num1-num2)
#打印结果：{4}
print(num2-num1)

#对称差集：集合1.symmetric_difference(集合2)
#集合 A 与集合 B 的并集减去集合 A 与集合 B 的交集
#打印结果均是：{1, 4}
print(num1.symmetric_difference(num2))
print(num2.symmetric_difference(num1))
#对称差集：集合1^集合2
print(num1^num2)

 25、函数的定义

def cal(qty, item,price):
    print(f'{qty} {item} cost ${price:.2f}')
 
#说明：
#1）使用def关键字来定义函数
#2）{price:.2f}表示保留两位小数

26、调用函数时，参数传递的方式：位置参数传递（直接传递）、关键字参数传递、默认参数

27、Python 函数中的 return 语句有两个作用：立即结束本函数的执行、返回数据给调用者

28、类与对象：概念篇

 

 1 #Person类
 2 class Person:
 3     #创建类的对象时会默认执行该方法，该方法为类的属性赋值
 4     #参数self必须存在，表示对象的引用
 5     #nation这个参数有默认的值
 6     def __init__(self,name,age,sex,nation='china'):
 7         self.name=name
 8         self.age=age
 9         self.sex=sex
10         self.nation=nation
11 
12     #类的成员方法，参数self必须存在，表示对象的引用
13     def get_dec(self):
14         return f'姓名：{self.name}\n年龄：{self.age}\n性别：{self.sex}\n国籍：{self.nation}'
15 
16 #创建对象
17 person=Person('zhangsan',18,'man')
18 #访问对象的属性
19 print(person.name)
20 #访问对象的成员方法
21 print(person.get_dec())
22 #修改对象的属性值
23 person.nation='中国'
24 print(person.nation)

29、类与对象：继承

#父类
class Animal:
    def __init__(self,name,fan):
        self.name=name
        self.fan=fan
    def eat(self):
        print(f"吃{self.fan}")

#子类Cat继承父类Animal
class Cat(Animal):
    #子类的__init__方法
    def __init__(self,name,fan,color):
        #name和fan属性可以通过调用父类的__init__方法来赋值
        super().__init__(name,fan)
        self.color=color
    def jiao(self):
        print("喵喵")

#实例化对象，对调用对象的成员方法
cat=Cat('猫','鱼','花色')
cat.eat()
cat.jiao()

 30、模块与包

'''
一个 .py 文件便是一个模块（Module）

当执行 import utils 这条指令时，Python 会从以下路径中搜索模块 utils.py:
1. 在当前目录下搜索该模块
2. 在环境变量 PYTHONPATH 指定的路径列表中依次搜索
3. 在 Python 安装路径的 lib 库中搜索

导入模块的两种方法：
1、直接导入模块
2、from 模块名 import 方法名,有时候，为了方便，会使用 from module_name import * 来导入模块中的所有对象
'''
import utils
from utils import min_num
print(utils.max_num(5,10))
print(min_num(4,1))

'''
Python 中的包实现了对模块分组管理的功能
包相当于一个文件夹，模块则相当于文件夹中的文件
导入包中模块对应的对象，一般用from pkg.utils1 import max_num，这样可以直接使用max_num这个方法
'''

 31、异常处理

#加了异常捕获和处理代码之后，当发生异常时，整个程序没有崩溃，而是继续执行后面的代码，所以输出了 Done!
try:
    print(1 / 0)
except ZeroDivisionError:
    print("ZeroDivisionError happened!")

print("Done!")

'''
try 语句块后面可以跟上多个 except 语句块。
在执行代码 print(1 / 0) 时，发生了除 0 异常，所以没有执行后面的打开文件的代码，后面的异常处理代码输出了 ZeroDivisionError happened!
'''
try:
    print(1 / 0)
    #除0异常
    with open('test.log') as file:
    #文件不存在异常
        read_data = file.read()
except ZeroDivisionError:
    print("ZeroDivisionError happened!")
except FileNotFoundError:
    print("FileNotFoundError happened!")

print("Done!")

'''
try-except 语句块后面可以跟上 else 语句块，当没有异常发生时，会执行 else 语句块中的代码。
程序中没有发生异常，所以执行 else 语句块中的代码，输出了 Exception not happened。
'''
try:
    print(1 / 1)
except ZeroDivisionError:
    print("ZeroDivisionError happened!")
else:
    print("Exception not happened")

print("Done!")

'''
try-except-else 语句块后面还可以跟上 finally 语句块，不管有没有发生异常，finally 语句块中的代码都会被执行。
没有发生异常时，除了执行 else 语句块中的代码，输出了 Exception not happened，finally 语句块中的代码也得到了执行，输出了 Finally is executed! 。
'''
try:
    print(1 / 1)
except ZeroDivisionError:
    print("ZeroDivisionError happened!")
else:
    print("Exception not happened")
finally:
    print("Finally is executed!")

print("Done!")

'''
主动抛出异常，使用关键字raise:raise Exception()
'''

 32、综合练习题

import random

'''
实现一个猜数字游戏，首先使用 random 模块中的随机函数生成一个位于 [1, 100] 范围内的数字，然后让机器人玩家来猜，比较机器人玩家猜的数字和生成的随机数，如果随机数大于玩家猜的数字告诉玩家猜的数字过小，如果随机数小于玩家猜的数字告诉玩家猜的数字过大，直到玩家猜到正确的数字。
提示：生成 1~100 的随机数可以使用 random.randint(1, 100)
'''

#猜测的数字通过命令行输入
def fun1():
    rvalue = random.randint(1, 100)
    while True:
        robot_value = int(input("机器人玩家输入猜测的数字:"))
        if robot_value > rvalue:
            print(f"机器人玩家猜测的数字为{robot_value},该数字过大！")
        elif robot_value < rvalue:
            print(f"机器人玩家猜测的数字为{robot_value},该数字过小！")
        else:
            print(f"机器人玩家猜中了！数字为{robot_value}")
            break

#通过生成随机数自动猜测
def fun2():
    random_value = random.randint(1, 100)
    robot_value=random.randint(1,100)
    height=100
    low=1
    while True:
        if robot_value > random_value:
            print(f"实际数字为{random_value},机器人玩家猜测的数字为{robot_value},该数字过大！")
            height=robot_value-1
            robot_value=(height+low)//2 #//表示整数除法
        elif robot_value < random_value:
            print(f"实际数字为{random_value},机器人玩家猜测的数字为{robot_value},该数字过小！")
            low = robot_value +1
            robot_value = (height + low) // 2
        else:
            print(f"机器人玩家猜中了！数字为{robot_value}")
            break
'''
实现一个剪刀、石头、布的游戏，首先使用 random 模块的函数从列表 ['剪刀', '石头', '布'] 中随机选择一个，然后机器人玩家也随机出一个，比较两个，判断玩家是输是赢。最后给出机器人玩家赢了几次，输了几次，平了几次。
提示：从列表 '剪刀', '石头', '布'] 随机选择，可以使用 random.choice(['剪刀', '石头', '布']
'''
def fun3():
    ping, ying, shu = 0, 0, 0
    count=int(input("请输入要玩的次数："))
    while count>=1:
        random_value =random.choice(['剪刀', '石头', '布'])#对方出
        robot_value=random.choice(['剪刀', '石头', '布'])#机器人玩家出
        count-=1#玩一轮，轮数减少一次
        print(f'对方是{random_value},机器人玩家出了{robot_value}')
        if robot_value=='石头':
            if random_value=='石头':
                ping+=1
            elif random_value=='剪刀':
                ying+=1
            else:
                shu+=1
        elif robot_value=='剪刀':
            if random_value=='石头':
                shu+=1
            elif random_value=='剪刀':
                ping+=1
            else:
                ying+=1
        else:
            if random_value=='石头':
                ying+=1
            elif random_value=='剪刀':
                shu+=1
            else:
                ping+=1
    print(f'机器人玩家赢了{ying}次，输了{shu}次，平了{ping}次')