java经验快速学习python！

前言：现在python的应用方向越来越多了，如日中天的DeepSeek也是python开发的，目前现在的大学生学习的也是python语言，感受到了，这是一个趋势，不能不了解这门语言了。

本篇文档会一直更新！！！

通过在github开源100天可以看到，按照上面的学习路线结合人工智能的定向方案，一起学习。

下方图片：我半年以前是有学习过一遍了，太久没用了，过一遍基础操作，半小时理解一下。

变量、分支结构、循环结构、数据结构【列表、元组、集合字典】

import math
# 学习python的输入输出打印 +变量定义
print(123.456)
print(1.23456e2)
radius=float(input('请输入圆的半径：'))
print(radius)
area=math.pi * radius ** 2
print(f'面积: {area}')
print(f'面积: {area:.2f}')

# 学习类型转换 +打印输出格式化 +判断语句 ifelse和match+case
height = float(input('身高(cm)：'))
weight = float(input('体重(kg)：'))
bmi = weight / (height / 100) ** 2
print(f'{bmi = :.1f}')
if 18.5 <= bmi < 24:
    print('你的身材很棒！')

status=int(input("响应状态码："))
match status:
    case 400:
        description='Bad Request'
    case 401:
        description='Unauthorized'
    case 402:
        description='Forbidden'
    case 403:
        description='Forbidden'
    case 500 |501:
        description='Server Error'
    case _:
        description='Unknown Error'
print('状态码：',description)
# 学习 range 函数+ time模块sleep休眠函数
import time

for i in range(10,100):
    print(i)
    print('Hello World!')
    time.sleep(1)
# 学习random 随机数+range函数生成1-5999的数字
import random

f1=0
f2=0
f3=0
f4=0
f5=0
f6=0
for i in range(6000):
    face=random.randrange(1,7)
    if face==1:
        f1+=1
    elif face==2:
        f2+=2
    elif face==3:
        f3+=3
    elif face==4:
        f4+=4
    elif face==5:
        f5+=5
    elif face==6:
        f6+=6
print(f'1点出现了{f1}次')
print(f'2点出现了{f2}次')
print(f'3点出现了{f3}次')
print(f'4点出现了{f4}次')
print(f'5点出现了{f5}次')
print(f'6点出现了{f6}次')
# 学习列表 取值与定义，可以点进去具体方法里面看都有什么类型的方法
items=list(range(100))
print(items)

items=['Python','Java','C++','C#','JavaScript']
if 'Python' in items:
    items.reverse()
print(items)

python常用内置函数

元组和列表的比较

这里还有一个非常值得探讨的问题，Python 中已经有了列表类型，为什么还需要元组这样的类型呢？这个问题对于初学者来说似乎有点困难，不过没有关系，我们先抛出观点，大家可以一边学习一边慢慢体会。

1. 元组是不可变类型，不可变类型更适合多线程环境，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解并发编程的时候跟大家一起探讨。
2. 元组是不可变类型，通常不可变类型在创建时间上优于对应的可变类型。我们可以使用timeit模块的timeit函数来看看创建保存相同元素的元组和列表各自花费的时间，timeit函数的number参数表示代码执行的次数。下面的代码中，我们分别创建了保存1到9的整数的列表和元组，每个操作执行10000000次，统计运行时间。

import timeit

print('%.3f 秒' % timeit.timeit('[1, 2, 3, 4, 5, 6, 7, 8, 9]', number=10000000))
print('%.3f 秒' % timeit.timeit('(1, 2, 3, 4, 5, 6, 7, 8, 9)', number=10000000))

items=list(range(100))
print(items)

items=['Python','Java','C++','C#','JavaScript']
if 'Python' in items:
    items.reverse()
print(items)

#同类型三元组
t1=(32,45,96)
# 不同类型四元组
t2=(23,'zhangsan',True,'lisi')
# 学习type函数，查看变量的类型
print(type(t1))
print(type(t2))
# 学习 len函数，查看变量的数量
print(len(t1))
print(len(t2))
# 学习 元组的索引计算
print(t1[0])
print(t1[1])
print(t1[-1])
print(t1[-2])
#学习切片运算
print(t2[:2]) # 切片，在切片第2个元素前结束
print(t2[::3]) # 切片，从0开始，在下标3前结束
# 循环打印元组元素
for i in t1:
    print(i)
# 成员运算 下方的例子可以看成if判断
print(32 in t1) #True
print(45 in t1) #True
print(78 in t1) #False
# 拼接运算 元组t1+元组t2 成为一个新元组t3
t3=t1+t2
print(t3)
# 比较运算
print(t1 == t3)            # False
print(t1 >= t3)            # False
print(t1 <= (35, 11, 99))  # False
# 学习打包和解包操作
# 打包操作
a = 1, 10, 100
print(type(a))  # <class 'tuple'>
print(a)        # (1, 10, 100)
# 解包操作
i, j, k = a
print(i, j, k)  # 1 10 100

# 学习集合
tupic=(1,2,3,4) # 这是一个元组
print(tupic)
list={1,2,3,4,5,6,7,8,9,10} # 这是一个集合
print(list)
print(set('hello'))
#学习字典
dict1={'a':1,'b':2,'c':3,'d':4}
print(dict1)

字符串占位符

函数的使用进阶，以及函数的高级应用

import functools
import operator
import string
import random
import time

# 所有数字和所有字母的字符集
chars=string.digits+string.ascii_letters

def generate_code(*,code_len=4):
    return ''.join(random.choices(chars,k=code_len))
# 学习 定义入参类型 num:int，和定义返回参数类型 ->bool
def is_prime(num:int)->bool:
    """
        判断一个正整数是不是质数
        :param num: 大于1的正整数
        :return: 如果num是质数返回True，否则返回False
        """
    for i in range(2,int(num**0.5)+1):
        if num%i==0:
            return False
    return True

for _ in range(5):
    print(generate_code())

def calc(*args,**kwargs):
    items=list(args)+list(kwargs.values())
    result=0
    for item in items:
        if(type(item) in (int,float)):
            result+=item
    return result

def calc(int_value,of_func,*args,**kwargs):
    items=list(args)+list(kwargs.values())
    result=int_value
    for item in items:
        if(type(item) in(int,float)):
            result=of_func(result,item)
    return result

def add(x,y):
    return x + y
def mul(x,y):
    return x*y
# 学习将函数传递给函数
# 通过参数名的方式
print(calc(0,add,1,2,3,4,5))
print(calc(1,mul,1,2,3,4,5))

def is_even(num):
    return num%2==0
def square(num):
    return num**2
old_nums=[35,46,73,52,90]
nums_news=[num **2 for num in old_nums if num%2==0]
print(nums_news)

#lambda函数
old_nums = [35, 12, 8, 99, 60, 52]
new_nums=list(map(lambda x:x**2,filter(lambda y:y%2==0,old_nums)))
print(new_nums)

#用一段代码实现计算阶乘的函数
fac=lambda n:functools.reduce(operator.mul,range(2,n+1),1)

#用一段代码实现判断素数的函数
is_prime =lambda x:all(map(lambda f:x%f,range(2,int(x**0.5)+1)))

#调用lambda 函数
print(fac(6))
print(is_prime(37))




# 装饰器函数
def recode_time(func):
    @functools.wraps(func)
    def wrapper(*args,**kwargs):
        start=time.time()
        result=func(*args,**kwargs)
        end =time.time()
        print(f'{func.__name__}执行时间:{end-start:.2f}秒')
        return result
    return wrapper

#学习装饰器函数
@recode_time
def down(filename):
    print(f'正在下载{filename}')
    time.sleep(random.random()*6)
    print(f'{filename}下载完成')

@recode_time
def upload(filename):
    print(f'正在上传{filename}')
    time.sleep(random.random()*8)
    print(f'{filename}上传完成')

down('Mysql从删库到跑路')
upload('Python从入门到住院')

递归调用

# 递归调用
# 使用 Python 标准库中functools模块的lru_cache函数来优化上面的递归代码
@functools.lru_cache
def fac(num):
    if num in (0,1):
        return 1
    return num*fac(num-1)
print(fac(5))

面相对象编程应用小例子

Employee.py

from abc import ABCMeta, abstractmethod


class Employee(metaclass=ABCMeta):
    def __init__(self,name):
        self.name=name

    @abstractmethod
    def get_salary(self):
        pass

class Manager(Employee):
    def get_salary(self):
        return 15000.00
class Programmer(Employee):
    def get_salary(self,name,working_hour=0):
        super().__init__(name)
        self.working_hour=working_hour
    def get_salary(self):
        return 200*self.working_hour
class Salesman(Employee):
    def __init__(self,name,sales=0):
        super().__init__(name)
        self.sales=sales
    def get_salary(self):
        return 1800*self.sales*0.05

emps=[Manager('刘备'),Programmer('诸葛亮'),Manager('曹操'),Programmer('荀彧'),Salesman('张辽')]
for emp in emps:
    if isinstance(emp,Programmer):
        emp.working_hour=int(input(f'请输入{emp.name}本月工作时间'))
    elif isinstance(emp,Salesman):
        emp.sales=float(input(f'请输入{emp.name}本月销售额'))
    print(f'{emp.name}本月工资为：￥{emp.get_salary():.2f}元')

Card.py

import random
from enum import Enum


class Suite(Enum):
    SPADE,HEART,CLUB,DIAMOND=range(4)

for suite in Suite:
    print(f'{suite}:{suite.value}')
class Card:
    def __init__(self,suite,face):
        self.suite=suite
        self.face=face
    def __repr__(self):
        suites='♠♥♣♦'
        faces=['', 'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
        return f'{suites[self.suite.value]}{faces[self.face]}'#返回牌的花色和点数
    def __lt__(self, other):
        if self.suite == other.suite:
            return self.face < other.face
        return self.suite.value<other.suite.value
card1=Card(Suite.SPADE,5)
card2=Card(Suite.HEART,13)
print(card1)
print(card2)

class Poker:
    def __init__(self):
        self.cards=[Card(suite,face)
                    for suite in Suite
                    for face in range(1,14)]
        self.current=0
    def shuffle(self):
        self.current=0
        random.shuffle(self.cards)
    def deal(self):
        card=self.cards[self.current]
        self.current+=1
        return card
    @property
    def has_next(self):
        return self.current < len(self.cards)

poker=Poker()
print(poker.cards)
poker.shuffle()
print(poker.cards)

class Player:
    def __init__(self,name):
        self.name=name
        self.cards=[]
    def get_one(self,card):
        self.cards.append(card)
    def arrange(self):
        self.cards.sort()
poker=Poker()
poker.shuffle()
players=[Player('东邪'),Player('西毒'),Player('南帝'),Player('北丐')]
for _ in range(13):
    for player in players:
        player.get_one(poker.deal())
for player in players:
    player.arrange()
    print(f'{player.name}:',end='')
    print(player.cards)