AI体系化知识专栏：基础-Python常见语法

'''
在Python代码中，我们可以通过input()函数接收外部设备的输入。
注意：接受到的任何数据都是字符串类型
'''
password = input('请输入您的银行卡密码：')
print(password)
print(type(password))

num1 = int(input('请输入一个整数：'))
print(num1)
print(type(num1))

num2 = float(input('请输入一个浮点数：'))
print(num2)
print(type(num2))

在Python代码中，我们可以使用print()函数实现变量或数据的打印输出
print(变量1)
print(变量2)
print(变量3)

print(变量1, 变量2, 变量3)

完整写法
print(变量或内容, sep='分隔符', end='结束符')
'''
# print("Sun", "Mon", "Tue", "Wed", sep='\n', end=';')

'''
在Python中，print()不仅可以实现普通变量的打印输出，还可以使用f形式对其进行格式化输出，基本语法：
print(f'xxx{变量名称}xxx')
'''
#案例1：定义两个变量 => name = 'Rose'，age = 19，期望的输出结果：我的名字叫做Rose，今年19岁了！
name = 'Rose'
age = 19
print(f'我的名字叫做{name}，今年{age}岁了！')

#案例2：定义两个变量 = goods_name = '胡萝卜', goods_price = 5.5，期望输出结果：今天蔬菜特价了，胡萝卜只要5.50元/斤！
goods_name = '胡萝卜'
goods_price = 5.5
print(f'今天蔬菜特价了，{goods_name}只要{goods_price:.2f}元/斤！')

'''
案例：提示用户输入用户的年龄信息，18岁以下提示童工一枚；18-60周岁提示合法工龄；超过60提示退休年龄。
'''
# 1. 定义一个变量，用于接收用户的年龄
age = int(input('请输入您的年龄：'))
# 2. 使用if...elif...else结构
if age < 18:
    print('童工一枚')
elif 18 <= age <= 60:
    print('合法工龄')
else:
    print('退休年龄')

案例：法律规定，车辆驾驶员的血液酒精含量小于 20mg/100ml 不构成酒驾；酒精含量大于或等于 20mg/100ml 为酒驾；酒精含量大于或等于 80mg/100ml 为醉驾。编写 Python 程序判断是否为酒后驾车。
'''
# 定义一个变量，接收酒精含量
proof = int(input('请输入车辆驾驶员每100ml血液中酒精含量：'))
# 使用if判断是否构成酒驾
if proof >= 20:
    if proof >= 80:
        print('涉嫌醉驾！')
    else:
        print('涉嫌酒驾！')
else:
    print('不构成酒驾！')

from random import randint
# 1. 获取玩家出拳信息
player = int(input('请输入您的出拳信息（1-石头、2-剪刀、3-布）：'))
# 2. 获取电脑出拳信息
computer = randint(1, 3)
# 3. 输赢比较
if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3 and computer == 1):
    print('玩家获胜')
elif player == computer:
    print('平局')
else:
    print('电脑获胜')

for i in 'itheima':
    print(i)

'''
思路分析：
第一步：循环操作，从1循环到100
第二步：定义一个变量，如sum = 0，用于接收1-100累加的结果
第三步：在循环体内部，每循环1次，累加得到的结果
'''
# 1. 从1循环到100
# 2. 定义一个变量，用于接收1-100累加的结果
sum = 0
for i in range(1, 101):
    # 3. 在循环体内部，每循环1次，累加得到的结果
    sum += i  # sum += i等价于sum = sum + i
print(sum)

for i in range(1, 6):
    if i == 4:
        print('已经吃饱了，后面的香蕉不吃了！')
        break
    print(f'正在吃第{i}个香蕉！')

正在吃第1个香蕉！
正在吃第2个香蕉！
正在吃第3个香蕉！
已经吃饱了，后面的香蕉不吃了！

for i in range(1, 6):
    if i == 3:
        print('不好，有大虫，这个香蕉不吃了！')
        continue
    print(f'正在吃第{i}个香蕉！')

正在吃第1个香蕉！
正在吃第2个香蕉！
不好，有大虫，这个香蕉不吃了！
正在吃第4个香蕉！
正在吃第5个香蕉！

# 猜数字游戏规则：
# ① 系统随机生成1-10之间的一个数字
# ② 一共3次猜数字机会
# ③ 输入不同的数字，然后与系统生成的数字进行判断
# 有三种情况：
# 猜对了
# 猜大了
# 猜小了
# 1. 导入随机模块，生成一个随机数
from random import randint

rand_num = randint(1, 10)

# 2. 定义一个循环，循环3次
for i in range(3):
    # 3. 每次循环提示用户输入要猜的数字
    user_num = int(input('请输入您要猜的数字：'))
    # 4. 进行条件判断
    if user_num == rand_num:
        print('恭喜您，猜对了')
        break

    elif user_num > rand_num:
        print('很抱歉，猜大了')
    else:
        print('很抱歉，猜小了')

'''
如果定义一个列表呢？基本语法：列表名称 = [元素1, 元素2, 元素3]
每一个列表中的元素都有一个与之对应的索引下标
列表名称 = [元素1, 元素2, 元素3]
            0      1     2
列表名称[索引下标]

增加元素 => 列表名称.append(新元素)
删除元素 => del 列表名称[索引下标]
更新元素 => 列表名称[索引] = 更新后的值
查询元素 => 列表名称[索引下标]、for循环实现遍历操作
'''
list1 = [10, 20, 30]
print(list1[0])
print(list1[1])
print(list1[2])

# 增加元素
list1.append(40)
print(list1)

# 删除元素
del list1[1]
print(list1)

# 更新元素
list1[0] = 100
print(list1)

# for循环实现列表的遍历操作
for i in list1:
    print(i)

print(len([1,2,3])) #长度
print([1,2,3] + [4,5,6]) #组合
print(['Hello'] * 4) #重复
print(3 in [1,2,3]) #某元素是否在列表中
#列表的访问
abcd_list =['a', 'b', 'c', 'd']
print(abcd_list[1])
print(abcd_list[-2])
#列表的切片
print(abcd_list[1:])、print(abcd_list[:3]
print(abcd_list[1:3])、print(abcd_list[-4:-1:1]
print(abcd_list[:]、print(abcd_list[::-1]、print[::2]

# 1. 定义两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 2. 获取列表的长度
print(len(list1))

# 3. 使用+运算符实现列表合并
print(list1 + list2)

# 4. 使用*运算符实现列表元素的复制操作
print(list1 * 4)

# 5. in关键字，判断元素是否出现在列表中
print(3 in list1)

3
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
True

'''
基本语法：
    列表名称[起始索引:结束索引:步长]
① 看步长，步长为正则从左向右移动，步长为负，则从右向左移动
'''
abcd_list = ['a', 'b', 'c', 'd']
print(abcd_list[0:3:1])  # 1，代表从左向右移动 => abc
print(abcd_list[0:3])

print(abcd_list[0:])  # 从start（0）位置开始截取，一直截取到列表尾部（包含尾部元素）
print(abcd_list[:3])  # 从0开始截取，截取到stop-1结束
print(abcd_list[:])  # 截取整个列表
print(abcd_list[::-1])  # dcba
print(abcd_list[-4:-1])  # abc

# 列表操作包含以下函数:
# 1、len(list)：列表元素个数
# 2、max(list)：返回列表元素最大值
# 3、min(list)：返回列表元素最小值
# 4、list(seq)：将元组转换为列表

# 列表操作包含以下方法:
# 1、list.append(obj)：在列表末尾添加新的对象
# 2、list.count(obj)：统计某个元素在列表中出现的次数
# 3、list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
# 4、list.remove(obj)：移除列表中某个值的第一个匹配项
# 5、list.reverse()：反向列表中元素
# 6、list.sort([func])：对原列表进行排序

# 1. 定义一个列表
list1 = [1, 2, 3, 1]
print(len(list1))

# 2. 获取列表中元素最大值与最小值
print(max(list1))
print(min(list1))

# 3. 定义一个元组
tuple1 = (10, 20, 30)
list2 = list(tuple1)
print(list2)
print(type(list2))

# 4. 获取列表元素在列表中出现次数
count = list1.count(1)
print(count)

# 5. 使用extend方法实现列表的合并操作
list1.extend([4, 5, 6])
print(list1)

# 6. 使用remove移除列表中的元素6
list1.remove(6)
print(list1)

# 7. 定义一个列表，使用reverse方法实现对其翻转操作
list2 = [10, 20, 30]
list2.reverse()
print(list2)

# 8. 使用sort()方法实现对列表元素的排序
list2.sort() #正序
list2.sort(reverse=True) #倒序
print(list2)


4
3
1
[10, 20, 30]
<class 'list'>
2
[1, 2, 3, 1, 4, 5, 6]
[1, 2, 3, 1, 4, 5]
[30, 20, 10]
[30, 20, 10]

* 支持索引和切片操作，但不支持修改。
* 可以作为字典的键（因为不可变）。
* 常用于存储固定且不需要修改的数据

# 1. 定义一个单元素的元组
tuple1 = (10,)
print(tuple1)
print(type(tuple1))

# 2. 定义一个多元素的元组
tuple2 = (10, 20, 30)
print(tuple2)
print(type(tuple2))

# 3. 通过索引下标实现元组中元素的访问
print(tuple2[0])
print(tuple2[1])
print(tuple2[2])

# 4. 使用for循环实现元组的遍历操作
for i in tuple2:
    print(i)

# 1. 定义一个空字典
dict1 = {}
# 2. 定义有数据的字典
dict2 = {'title':'Python入门教程', 'price':9.98, 'publish':'菜鸟教程'}
print(dict2)
print(type(dict2))

# 3. 通过key获取字典元素值
print(dict2['title'])
print(dict2['price'])
print(dict2['publish'])

# 4. 字典的新增与更新操作
dict2['price'] = 6.69  #无key 则为增加操作
print(dict2)

# 5. 删除字典元素
del dict2['publish']
print(dict2)

# 6. 使用clear()方法实现字典的清空操作
dict2.clear()
print(dict2)

{'title': 'Python入门教程', 'price': 9.98, 'publish': '黑马程序员'}
<class 'dict'>
Python入门教程
9.98
黑马程序员
{'title': 'Python入门教程', 'price': 6.69, 'publish': '黑马程序员'}
{'title': 'Python入门教程', 'price': 6.69}
{}

# 1. 定义一个空集合
set1 = set()

# 2. 定义一个有数据集合
set2 = {1, 11, 22, 8, 9, 10}
print(set2)
print(type(set2))

# 3. 无序且天生去重
set3 = {1, 11, 22, 8, 9, 10, 8, 10, 11}
print(set3)

set11 = {1, 2, 3, 4, 5}
set22 = {4, 5, 6, 7, 8}
# 4. 交集
print(set11 & set22)
# 5. 并集
print(set11 | set22)
# 6. 差集
print(set11 - set22)


{1, 8, 9, 10, 11, 22}
<class 'set'>
{1, 8, 9, 10, 11, 22}
{4, 5}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3}

#集合的定义
a={3,5} #定义一个集合
type(a)
a_set=set(range(8,14))#将 range 对象转化为集合
b_set=set([0,1,2,3,0,1,2,3,7,8])#转化时自动去掉重复元素
c_set=set((1,2,3))
d_set=set({1:'a',2:'b'}.items())
print(a_set,b_set,c_set,d_set,sep="\n")


f_set=set() #空集合
d_set=set([8,9,10,11,12,13])
f_set={0,1,2,3,7,8}
d_set | f_set #并集
d_set.union(f_set) #并集
d_set & f_set #交集
d_set.intersection(f_set) #交集
d_set.difference(f_set) #差集
d_set-f_set #差集


{8, 9, 10, 11, 12, 13}
{0, 1, 2, 3, 7, 8}
{1, 2, 3}
{(2, 'b'), (1, 'a')}

案例1：要求定义一个打招呼程序，用于向同事打招呼 => 封装为一个函数 => 实现代码重用
案例2：封装一个函数，用于向不同的老师打不同的招呼 => 参数
案例3：函数执行完毕后，可以通过return给函数的调用位置一个返回值 => 返回值
#没有参数和没有返回值的函数
def greet():
  print("您好")
greet()

#有参数，无返回值
def greet(name):
  print(name + "，您好")
greet("张老师")


#有参数，有返回值
def greet(name):
  return name + "，您好"
result = greet("张老师")
print(result)

# 全局作用域
num1 = 10
# 定义一个函数
def func():
    # 局部作用域
    print(num1)

# 调用func()函数
func()

# 在全局作用域中访问全局变量
print(num1)

'''
结论：全局变量作用范围比较广，既可以在全局作用域中访问，也可以在局部作用域访问。
'''

# 定义一个函数
def func():
    # 局部作用域
    num2 = 100
    # 在局部作用域中访问局部变量
    print(num2)

# 调用func()函数
func()
# 在全局作用域中访问局部变量
print(num2) #无法调用

'''
结论：局部变量只能在局部作用域中访问，无法在全局作用域中访问，因为函数执行完毕后，其内部的局部变量也会随之消失！
'''

# 全局变量
num = 10
# 定义一个函数
def func():
    # 引入global关键字，作用：在局部作用域中声明全局变量
    global num
    num = 100

# 调用func()函数
func()
print(num)

# 位置传参
def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
    
# 调用函数（使用位置参数）
user_info('Tom', 23, '美国纽约')

#关键词传参
def user_info(name, age, address):
    print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
    
# 调用函数（使用关键词参数）
user_info(name='Tom', age=23, address='美国纽约')

# 1.默认参数（缺省参数）
def user_info(name, age, gender='男'):
    print(f'我的名字{name}，今年{age}岁了，我的性别为{gender}')
user_info('李林', 25)
user_info('振华', 28)
user_info('婉儿', 18, '女')

# 包裹位置参数：
def user_info(*args):
    # print(args)  # 元组类型数据，对传递参数有顺序要求
    print(f'我的名字{args[0]}，今年{args[1]}岁了，住在{args[2]}')
# 调用函数，传递参数
user_info('Tom', 23, '美国纽约')

# 包裹关键词参数：
def user_info(kwargs):
    # print(kwargs)  # 字典类型数据，对传递参数没有顺序要求，格式要求key = value值
    print(f'我的名字{kwargs["name"]}，今年{kwargs["age"]}岁了，住在{kwargs["address"]}')
# 调用函数，传递参数
user_info(name='Tom', address='美国纽约', age=23)

# 1. 定义一个普通函数
def func1():
    return 100

print(func1())

# 2. 使用lambda表达式
func2 = lambda : 100
print(func2)
print(func2())

100
<function <lambda> at 0x0000020130AE0EE0>
100

# 1. 带普通参数的lambda表达式
func1 = lambda a, b : a + b
print(func1(10, 20))

# 2. 带有默认值的参数lambda表达式
func2 = lambda a, b, c=100 : a + b + c
print(func2(10, 20))

# 3. 带有包裹位置参数的lambda表达式
func3 = lambda *args : args
print(func3(1, 10, 100))

# 4. 带有包裹关键词参数的lambda表达式
func4 = lambda **kwargs : kwargs
print(func4(a=1, b=10, c=100))

30
130
(1, 10, 100)
{'a': 1, 'b': 10, 'c': 100}

☆ 第一步：分析哪些动作是由哪些实体发出的
☆ 第二步：定义这些实体，为其增加相应的属性和功能
☆ 第三步：让实体去执行相应的功能或动作

☆ 第一步：分析哪些动作是由哪些实体发出的
学生提出报名
学生提供相关材料
学生缴费
机构收费
老师分配教室
班级增加学生信息 
于是，在整个过程中，一共有四个实体：学生、机构、老师、班级！在现实中的一个具体的实体，就是计算机编程中的一个对象！


☆ 第二步：定义这些实体，为其增加相应的属性和功能属性就是实体固有的某些特征特性信息，在面向对象的术语
中，属性就是以前的变量。
比如：
一个人的属性有：身高、体重、姓名、年龄、学历、电话、
籍贯、毕业院校等
一个手机的属性有：价格、品牌、操作系统、颜色、尺寸等

☆ 第三步：让实体去执行相应的功能或动作
学生提出报名
学生提供相关资料
教师登记学生信息
学生缴费
机构收费
教师分配教室
班级增加学生信息

# 1. 定义一个学生类
class Student(object):
 # 2. 定义属性和方法
    def eat(self):
        print("吃东西")

    def drink(self):
        print("我要喝东西")

# 3. 实例化Student类，获取s1对象
s1 = Student()
s1.eat()
s1.drink()

s2 = Student()
s2.eat()
s2.drink()

# 1、定义一个类
class Person():
    # 定义一个方法
    def speak(self):
        print(self)
        print('Nice to meet you!')


# 2、类的实例化（生成对象）
p1 = Person()
print(p1)
p1.speak()
p2 = Person()
print(p2)
p2.speak()

# 1. 定义一个Person类
class Person(object):
    # 定义属性和方法
    def speak(self):
        print(self)
        print('Nice to meet you!')

# 2. 实例化Person类获取p1对象
p1 = Person()
print(p1)

p1.speak()

<__main__.Person object at 0x000001E3545D5F40>
<__main__.Person object at 0x000001E3545D5F40>
Nice to meet you!

# 1. 定义一个Person类
class Person(object):
    pass

# 2. 创建一个p1对象
p1 = Person()
# 3. 设置属性
p1.name = 'Tom'
p1.age = 23
p1.address = '北京市昌平区'

# 4. 获取属性
print(p1.name)
print(p1.age)
print(p1.address)

Tom
23
北京市昌平区

# 1. 定义Person类
class Person(object):
    # 2. 定义属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 3. 实例化对象
p1 = Person('孙悟空', 30)
print(p1.name)
print(p1.age)

p2 = Person('猪八戒', 28)
print(p2.name)
print(p2.age)

孙悟空
30
猪八戒
28

class MyClass:
    def __init__(self, value):
        self.value = value

    def __call__(self, x):
        return self.value * x

# 创建 MyClass 的实例
obj = MyClass(3)

# 使用括号调用实例，就像调用函数一样
result = obj(4)

# 输出结果
print(result)  # 输出: 12

class Counter:
    def __init__(self):
        self.count = 0

    def __call__(self):
        self.count += 1
        return self.count

# 创建 Counter 类的实例
counter = Counter()

# 多次调用实例，并输出结果
print(counter())  # 输出: 1
print(counter())  # 输出: 2
print(counter())  # 输出: 3

class ClickHandler:
    def __init__(self):
        self.callbacks = []

    def register_callback(self, callback):
        self.callbacks.append(callback)

    def __call__(self, x, y):
        for callback in self.callbacks:
            callback(x, y)

# 使用示例
handler = ClickHandler()

def print_coords(x, y):
    print(f"Clicked at ({x}, {y})")

handler.register_callback(print_coords)

# 触发事件
handler(100, 200)  # 输出: Clicked at (100, 200)

class B(object):
    pass
class A(B):
    pass
a = A()
a.B中的所有公共属性
a.B中的所有公共方法

# 1. 定义一个Person类
class Person(object):
    # 2. 定义公共属性和公共方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):
        print('i can speak Chinese!')

# 2. 定义一个Student子类
class Student(Person):
    pass

# 3. 实例化子类对象
s1 = Student('Rose', 23)
print(s1.name)
print(s1.age)

s1.speak()

# 1. 定义一个Person类
class Person(object):
    # 2. 定义公共属性和公共方法
    def __init__(self):
        self.name = "tom"
        self.age = 18

    def speak(self):
        print('i can speak Chinese!')

# 2. 定义一个Student子类
class Student(Person):
    pass

# 3. 实例化子类对象
s1 = Student()
print(s1.name)
print(s1.age)

s1.speak()

# 1. 定义一个Animal父类
class Animal(object):
    def __init__(self):
        self.age=5
        self.color="blue"
    # 定义属性和方法
    def eat(self):
        print('i can eat food!')

    def sound(self):
        print('i can make a sound!')

# 2. 定义一个Dog类，继承Animal父类
class Dog(Animal):
    def __init__(self):
        self.age=2
        self.color="green"
    def sound(self):
        print('i can wang wang wang!')

# 3. 定义一个Cat类，继承Animal父类
class Cat(Animal):
    def __init__(self):
        self.age=4
        self.color="white"
    def sound(self):
        print('i can miao miao miao!')

# 4. 实例化子类对象

dog = Dog()
print(f"它的年龄是{dog.age}岁,颜色是{dog.color}")
dog.eat()
dog.sound()

cat = Cat()
cat.eat()
cat.sound()

# 1. 定义一个公共父类
class Car(object):
    # 2. 定义公共属性和公共方法
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def run(self):
        print('i can run!')

# 2. 定义一个燃油车
class GasolineCar(Car):
    def run(self):
        print('i can run with gasoline!')

# 3. 定义一个电动车
class EletricCar(Car):
    def __init__(self, brand, model, color, battery):
        # 强调调用父类中的__init__()魔术方法
        super().__init__(brand, model, color)
        self.battery = battery

    def run(self):
        print(f'i can run with eletric, i have a {self.battery} kWh battery！')

bmw = GasolineCar('宝马', 'X5', '蓝色')
print(bmw.brand)
print(bmw.model)
print(bmw.color)
bmw.run()

tesla = EletricCar('Tesla', 'Model S', '黑色', 82)
print(tesla.brand)
print(tesla.model)
print(tesla.color)
tesla.run()