python 简单 实例 python基础例子

打印当前程序的命令行输入参数及 Python 系统路径。

import sys

# 打印当前程序的命令行输入参数
for i in sys.argv:
    print (i)

print ('\nPython 系统路径：',sys.path)

声明变量注意事项

模块名包名： 小写字母，单词之间用下划线分割
类名：首字母大写 全局变量：大写字母，单词之间用下划线分割
普通变量：小写字母，单词之间用下划线分割
函数：小写字母，单词之间用下划线分割
实例变量：以下划线开头，其他和普通变量一样
专有变量：2个下划线开头，2个下划线结尾，一般为Python的自有变量（不要使用）

a = 123456、b = a，请简述 a 和 b 是什么关系?

变量 a 指向了 123456 的内存地址 变量 b 不是指向了 a 的地址，而是指向了123456内存地址

布尔值

布尔值：True 和 False
布尔值为False的有：[] 、()、{}、0、False等

随机数

from random import *
import string

# 随机一个[0,1)之间的浮点数
print(random())  
# 随机一个[0,100]之间的浮点数
print(uniform(0, 100)) 
# 随机一个[0,100)之间的偶数
print(randrange(0, 100, 2))
# 随机一个[0,100]之间的整数
print(randint(0, 100))  
## 随机字符
# 获取可打印字符
seed = string.printable
# 随机一个字符
print(choice(seed))           
# 随机多个字符（字符可重复）
print(sample(seed, 3))          
# 随机指定长度字符串（字符可重复）
print(''.join(sample(seed,3)))

华氏温度（℉）转换为摄氏温度（℃）

f = float(input('请输入华氏温度: '))
c = (f - 32) / 1.8
print('%.1f 华氏度 = %.1f 摄氏度' % (f, c))

计算计算周长和面积

import math

radius = float(input('请输入圆的半径: '))
perimeter = 2 * math.pi * radius
area = math.pi * radius * radius
print('周长: %.2f' % perimeter)
print('面积: %.2f' % area)

实现用户输入用户名和密码，当用户名为 admin 或 system 且密码为 admin 时，显示登陆成功，否则登陆失败，失败时允许重复输入三次

index = 0

while True:
    if index == 3:
        print("You have try too much times...")
        break
    else:
        user = input("Please input your name:")
        password = input("password:") 

        if user == "admin" or "system" and password == "admin":
            print("Welcome !\n")
        else:
            print("Sorry,your name or password is wrong...\n")

    index += 1

输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数

line = input("输入字符串：\n")
letters,space,digit,others = 0,0,0,0

for c in line:
    if c.isalpha(): 
        letters += 1
    elif c.isspace():
        space += 1
    elif c.isdigit():
        digit += 1
    else:
        others += 1

print("char = %d,space = %d,digit = %d,others = %d" % (letters,space,digit,others))

输入字符串 a、b，计算 b 在 a 中的索引。

a = input("a = ")
b = input("b = ")
print(a.find(b))

输入字符串 a、b，计算 a 中 b 出现的次数。

a = input("a = ")
b = input("b = ")
print(a.count(b))

一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

import math

"""
取值区间分析：
假设该整数为 x，A = x + 100, B = A + 168
∵ A 为完全平方数 
∴ A = x + 100 ≥ 0 => x ≥ -100
又假设 A = y**2, B = (y + n)**2
∵ A < B
∴ n ≥ 1 且为整数
∴ (y + n)**2 = y**2 + 168 
∴ y = 84/n - n/2 ≤ 83.5，取 n = 1
∴ x + 100 + 168 ≤ (y + n)**2 = 7,140.25
∴ x ≤ 6,872.25
∴ 取值范围可以限定为[-100,6,873]
"""

for i in range(-100,6873):
    m = int(math.sqrt(i + 100))
    n = int(math.sqrt(i + 100 + 168))

    if m * m == i + 100 and n * n == i + 268:
        print(i)

输出 9*9 乘法口诀表。

for i in range(1,10):
    for j in range(1,10):
        if j <= i:
            v = "%d*%d=%d" % (j,i,j * i)
            print("%-7s" % v,end="")
    print("")

有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子。假如兔子都不死，问每个月的兔子总数为多少？

x, y = 0, 1 # x 为每个月新增兔子对数，y 为每个月总兔子对数
for i in range(1, 13):
    print("第%2s个月：%3s对兔子" % (i,y))
    x, y = y, x + y

打印出所有的"水仙花数"

# 所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
# 例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
for i in range(100,1000):
    x = i // 100      # 百位
    y = i % 100 // 10   # 十位
    z = i % 10        # 个位

    if x ** 3 + y ** 3 + z ** 3 == i:
        print(i)

求s = a + aa + aaa + aaaa + aa…a 的值，其中 a 是一个数字。

# 例如：2 + 22 + 222 + 2222 + 22222(此时共有5个数相加)，几个数相加由键盘控制。
x = int(input("a = "))
n = int(input("n = "))
sum = 0
sv = ""

for i in range(1,n + 1):
    v = i * x * (10 ** (n - i))
    sum += v
    sv += str(x) * i + " + "
    print(f"v = {v}")

print("%s = %s" % (sum, sv.rstrip(" + ")))

有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和

x,y,n = 2,1,0

for i in range(20):
    n += x / y
    x = x + y # 第 2 项的分子等于第 1 项的分子 + 分母
    y = x - y # 第 2 项的分母等于第 2 项的分子 - 第 1 项的分母
print(n)

展示一下你对列表的操作

# 创建一个空列表，命名为names，往里面添加 Red、Green 和 Black 元素
names = ['Red','Green','Black']
print(names)
# 向列表names中的Black前面插入一个Blue，并将 Green 改成“绿色”
names.insert(-1,"Blue")
names[names.index("Green")] = "绿色"
print(names)
# 向列表names中Black后面插入子列表[“Gray”, “Night”]，并返回names列表中Blue的索引值（下标）
names.insert(names.index("Black"),["Gray", "Night"])
print(names)
index = names.index("Blue")
print(index)
# 创建新列表["Black", "Peach"]，合并到names列表中
others = ["Black", "Peach"]
names.extend(others)
print(names)
# 以步长为 1 取出列表names中索引4~7的元素，以步长为 2 取出names列表中索引2~10的元素
print(len(names))
subnames = names[4:8]
print(subnames)
subnames = names[2:11:2]
print(subnames)
# 切片（-3:）
subnames = names[-3:]
print(subnames)
#轮询列表names，当索引值为偶数时，把对应的元素改成 无
for v in names:
    index = names.index(v)

    if index % 2 == 0:
        names[index] = '无'
        print(index,v)
print(names)

for index,v in enumerate(names):
    if index % 2 == 0:
        names[index] = '无'
        print(index,v)
print(names)
# 列表names里有4个无，请返回第二个无的索引值，不要人肉，要动态找。
no = 0

for index,v in enumerate(names):
    if v == '无':
        no += 1

        if no == 2:
            print(index)
            break
    else:
        continue

print(names.index('无',names.index('无') + 1))

现有商品列表为：products = [[“Apple”,4], [“Fig”,30], [“Pear”,3], [“Plum”,10]]，请按“序号 名称 价格”纵向打印出列表中商品信息

products = [["Apple",4], ["Fig",30], ["Pear",3], ["Plum",10]]

for index,v in enumerate(products):
    print("%s%s%s" % (index,v[0].rjust(10),str(v[1]).rjust(5)))
# 根据products写一个循环，不断询问用户想买什么，用户选择一个商品编号， 就把对应的商品添加到购物车里，最终用户输入Q（或 q）退出时，打印购买的商品列表
cart = []       # 用户购物车
cost = 0        # 用户花费的金额
flag = False    # 标志位，默认设为False，退出
while not flag:
    print("------ 商品列表 ------")

    for index,v in enumerate(products):
        print("%s%s%s" % (index,v[0].rjust(10),str(v[1]).rjust(5)))

    item_index = input("\n输入你想购买的产品序号(按“q”退出):")

    if item_index.isdigit(): 
        # 判断用户输入的是否是数字
        item_index = int(item_index)  #强制转换为数字

        if item_index >= 0 and item_index < len(products):
            # 判断用户购买的商品是否在商品列表中
            cart.append(products[item_index]) # 加入购物车
            cost += products[item_index][1]  # 计算费用
            print("\n %s 已经加入你的购物车\n" % products[item_index])
        else:
            print("抱歉，此商品不存在\n")
    elif item_index == "q":
        # 用户选择退出
        if len(cart) > 0:
            # 判断用户是否购买了商品
            print("\n------ 你的购物车 ------")

            for index,v in enumerate(cart):
                # index和i为临时变量，与前一个for循环里index和i作用的列表不同，故可重用
                print("%s%s" % (index,v[0].rjust(10)))

            print("\n你此次购物的花费合计是:%s元\n" % cost)
            flag = True # 退出购物
        else:
            flag = True # 未购买商品，不打印购物车商品，直接退出
    else:
        # 输入不合法
        flag = True

已知集合：A = [‘香蕉’, ‘苹果’, ‘橙子’]、B = [‘可乐’, ‘牛奶’]，计算集合A、B的全排列，并将结果保存至新的列表中

A = ['香蕉', '苹果', '橙子']
B = ['可乐', '牛奶']
L = [(x, y) for x in A for y in B]
print(L)

已知集合：L = [“Jack”, “Lucy”, 50, 60, “Tom”]

(1) 将 L 中所有小写字符串转换为大写；

(2) 将 L 中所有小写字符串转换为大写，并将转换后的字符串保存至一个新的列表中。

L = ["Jack", "Lucy", 50, 60, "Tom"]
ALL = [v.upper() if isinstance(v, str) else v for v in L]
print(ALL)

SL = [v.upper() for v in L if isinstance(v, str) ]
print(SL)

有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

vs = []

for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            n = 100 * i + 10 * j + k

            if i != j and j != k and i != k and n not in vs:# 互不相同且无重复数字的三位数
                vs.append(n)

print(len(vs),vs)

企业发放的奖金根据利润(I)的多少来提成：

# （1）利润低于或等于10万元时，奖金可提10%；
# （2）利润介于10万元到20万之间时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；
# （3）利润介于20万到40万之间时，高于20万元的部分，可提成5%；
# （4）利润介于40万到60万之间时，高于40万元的部分，可提成3%；
# （5）利润介于60万到100万之间时，高于60万元的部分，可提成1.5%；
# （6）利润高于100万元时，超过100万元的部分按1%提成。
# 从键盘输入当月利润I，求应发放奖金总数？
money = int(input('净利润:')) 
profit = [1000000,600000,400000,200000,100000,0]
rate = [0.01,0.015,0.03,0.05,0.075,0.1]
bonus = 0

for i in range(len(profit)):
    if money > profit[i]:                    # 对于处于区间的部分
        bonus+=(money - profit[i]) * rate[i] # 计算并累加奖励
        money = profit[i]                    # 剩余部分

print(bonus)

遍历字典

D = {1: 'One', 2: 'Two', 3: 'Three'}

# keys
for v in D.keys():
    print(v)
# items
for k,v in D.items():
    print('%d%s' % (k, v.rjust(10)))

# 添加键值对
D[4] = 'Four'
print(D)

# 删除键值对
D.pop(1)  # 方法1：可以返回删除的 key 对应的 value，不存在则会引发异常
# del ds[1]  # 方法2：不返回删除的 key 对应的value，不存在则会引发异常
print(D)

# 1.5 删除键值对应的值
print(D.pop(5,None)) # None

# 1.6 获取键 key 对应的值
print(D[2])       # 方法1：不存在时，会报错
print(D.get(2))   # 方法2：不存在时，返回 None

# 1.7 将 dic = {5: 'Five', 6: 'Six'} 添加到 ds
dic = {0: 'Zero', 6: 'Six'}
D.update(dic)
print(D)

列表与字典混合操作

ls = [[0, [1, 'Two', {3: [4, 'Five', 'Six' ]}, 7], 8]]

# 2.1 将列表中的 'Five' 变成大写
print(ls[0][1][2].get(3)[1].upper())

# 2.2 将数字 4 变成字符串 'Four'
ls[0][1][2].get(3)[0] = 'Four'
print(ls[0][1][2].get(3)[0])

# 2.3 将列表中的字符串 'Six' 变成数字 6
ls[0][1][2][3][2] = 6
print(ls[0][1][2][3][2])

及格科目的信息

D = {'英语':66, '数学':78, '政治':42, '语文':59}
scores = {k:v for k, v in D.items() if v >= 60}
print(scores)

简单通讯录

print('|---欢迎进入通讯录程序---|')
print('|---1：查询联系人资料 ---|')
print('|---2：插入新的联系人 ---|')
print('|---3：删除已有联系人 ---|')
print('|---4：退出通讯录程序 ---|')
print('')
d={}
while(1):
    n=input('请输入相关的指令代码：')
    if(n=='1'):
        key=input('请输入联系人姓名：')
        print(key+':'+d[key])
        print('') 
    elif(n=='2'):
        key=input('请输入联系人姓名：')
        if(key in d):
            print('您输入的姓名在通讯录中已存在'+'-->>'+key+':'+d[key])
            iis=input('是否修改用户资料(YES/NO)')
            if iis=='YES':
                value=input('请输入用户联系电话：')
                d[key]=value
        else:
            value=input('请输入用户联系电话：')
            d[key]=value
        print('')
    elif(n=='3'):
        key=input('请输入联系人姓名：')
        value=d.pop(key)
        print('已删除'+key+value)
        print('')
    elif(n=='4'):
        print('|---感谢使用通讯录程序---|')
        print('')
        break

明明想在学校中请一些同学一起做一项问卷调查，

为了实验的客观性他先用计算机生成了N个1～1000之间的随机整数(N<=1000)，N是明明从键盘输入的，对于其中重复的数字，只保留一个， 把其余相同的数字去掉，不同的数对应着不同的学生的学号，然后再把这些数从小到大排序，按照排好的顺序去找同学做调查， 请你协助明明完成“去重”与排序工作。

import random

s = set([])

for i in range(int(input('N:'))):
    s.add(random.randint(1,1000))

print(s)
print(sorted(s))

已知在某个公司中，有职员曹操，刘备，孙权，张飞，关羽，他们的关系满足： 经理有：曹操，刘备，孙权技术员：曹操，孙权，张飞，关羽请用集合知识求：

# （1）既是经理也是技术员的有谁？
# （2）是技术员但不是经理的人有谁？
# （3）是经理，但不是技术员的有谁？
# （4）张飞是经理吗？
# （5）身兼一职的人有谁？
# （6）经理和技术员共有几人？
A = {'曹操','刘备','孙权'}
B = {'曹操','孙权','张飞','关羽'}
C = {'张飞'}

print("即是经理也是技术员的是：", A & B)
print("是技术员但不是经理的是：",B - A)
print("是经理但不是技术员的是：",A - B)
print("张飞是经理吗？",C < A,"\nTure是经理，False不是经理")
print("身兼一职的人有：",A ^ B)
print("经理和技术员共有：",len(A | B),"人")
from datetime import datetime as dt
from dateutil.parser import parse as dp
import calendar
import locale

假设学校开学日期所在周为第一教学周，输入学校开学日期，问当前日期为第几教学周？

sdt = dp(input("输入开学日期："))
# 2020.2.27 => (2020,10,1)
sweek = sdt.isocalendar()[1] 
eweek = dt.now().isocalendar()[1]

print("今天（%s）是第 %d 教学周！" 
      % (dt.strftime(dt.now(), "%Y-%m-%d"),eweek - sweek + 1))

输入一个日期，判断该日期的所在月份有多少天？

yy = int(input("输入年份: "))
mm = int(input("输入月份: "))
mr = calendar.monthrange(yy,mm)

print('%d年%d月当月的总天数为：%d' % (yy,mm, mr[1]))

输入年月，生成中文日历，并将星期天放在首位。

输入指定年月

yy = int(input("输入年份: "))
mm = int(input("输入月份: "))

设置当前语言格式

locale.setlocale(locale.LC_ALL, 'zh_CN')

设置日历的第一天为星期天

calendar.setfirstweekday(firstweekday = calendar.SUNDAY)

获取日历

lines = calendar.month(yy,mm).strip('\n').split('\n')

index = 0
linelen = len(lines[1]) * 2 - 6

for line in lines:
    line = line.strip()

    if index == 0:# 打印年月
        print(line.center(linelen) + "\n")
    elif index == 1:# 打印星期
        print(line)
    else: # 打印日期
        vs = line.split(" ")
        
        row = ""

        for v in vs:
            if v != '':
                row += v.rjust(2).center(4) + " "        

        if index == len(lines) - 1:
            print(row)
        else:
            row = row.strip() + " "
            print(row.rjust(linelen))

    index += 1# 1、最大公约数和最小公倍数
def gcd(x, y):
    """求最大公约数"""
    (x, y) = (y, x) if x > y else (x, y)

    for factor in range(x, 0, -1):
        if x % factor == 0 and y % factor == 0:
            return factor

def lcm(x, y):
    """求最小公倍数"""
    return x * y // gcd(x, y)

判断回文数

def is_palindrome(num):
    """判断一个数是不是回文数"""
    temp = num
    total = 0
    while temp > 0:
        total = total * 10 + temp % 10
        temp //= 10
    return total == num

判断素数

def is_prime(num):
    """判断一个数是不是素数"""
    for factor in range(2, num):
        if num % factor == 0:
            return False
    return True if num != 1 else False

判断输入的正整数是不是回文素数

def is_palindrome_or_prime(num):
    return (is_palindrome(num),is_prime(num))

采用递归函数生成斐波那契数列

def fibonacci(n): 
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

判断输入的正整数是不是回文素数

if __name__ == '__main__':
    n = int(input('请输入正整数: '))
    iop = is_palindrome_or_prime(n)

    if iop[0] and iop[1]:
        print('%d 是回文素数！' % n)
    elif iop[0]:
        print('%d 是回文数！' % n)
    elif iop[1]:
        print('%d 是素数！' % n)
    else:
        print('%d 既不是回文数，也不是素数！' % n)

    for x in range(n):
        print(fibonacci(x), end = ' ')

使用生成器编程实现生产者消费者模型

import time

def consumer(name):
    print('我是【%s】,我准备开始吃包子了' % name)

    # 等包子过程
    while True:
        baozi = yield
        time.sleep(0.1)
        print('%s 很开心的把【%s】吃掉了' % (name,baozi))

def producer():
    c = consumer('ZS')
    #c.__next__()
    next(c)

    for i in range(10):
        time.sleep(0.1)     
        c.send('包子 %s' % i)  #发送的值，就是yield的返回值

producer()

print()

使用生成器编写一个生成斐波那契数列的函数

import sys

def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return

        yield a

        a, b = b, a + b
        counter += 1

fib = fibonacci(10) # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(fib), end=" ")
    except StopIteration:
        '''退出程序引发 SystemExit 异常, 可以捕获异常执
          行些清理工作。n 默认值为 0, 表示正常退出，
          其他都是非正常退出。'''
        sys.exit(0)

在区间[1 100]内随机生成20个整数的列表A，并将A中的数从小到大排序，然后写入文件，接着从文件中的内容读出至列表B中，最后将B中数据从大到小排序并追加到文件的下一行。

from random import randint

A = [randint(1, 100) for i in range(1, 20)]
A.sort()
txt = ','.join(list(map(str, A)))# map(函数, 一个或多个序列)：根据指定函数对指定序列做映射
with open('sort.txt', 'w', encoding='utf-8') as fd: # with：具有自动关闭文件释放资源功能
    fd.write(txt)

with open('sort.txt', 'r+', encoding='utf-8') as fd:
    B = fd.read().split(',')
    B.reverse()
    txt = ','.join(list(map(str, B)))
    fd.write('\n')
    fd.write(txt)

在文件 student.txt 中，有格式如下学生记录，写一个程序，

删除id为15102102的行。

15102101，张三

15102102，李四

15102103，王二

import os

rfn = r'student.txt'
wfn = '%s.new' % rfn
id = '15102102'

with open(rfn, 'w', encoding='utf-8') as fd:
    fd.writelines(['15102101，张三\n', 
                   '15102102，李四\n',
                   '15102103，王二'])

with open(wfn, 'w', encoding='utf-8') as wfd:
    with open(rfn, 'r', encoding='utf-8') as rfd:
        for v in rfd:
            if id in v:
                pass
            else:
                wfd.write(v)

os.replace(wfn,rfn)

写一个查找文件内容的函数，用户指定要查找的文件和内容，将文件中包含要查找内容的每一行前添加序号后以生成器的方式返回，最后调用该函数将返回结果输出到屏幕。

def Find(filename,aim):
    try:
        with open(filename,encoding='utf-8') as fd:
            index = 0
    
            for line in fd:
                if aim in line:
                    index += 1
                    yield ('%s ' + line) % index
    except IOError as ex:
        print(ex.args)

vs = Find('Lx-2-12 文件.py', 'with')

for v in vs:
    print(v.strip())# 1、编写一个计算减法的方法 Sub(a, b) ，当 a 小于 b 时，
#   抛出“被减数不能小于减数”的异常。
def Sub(a, b): # 定义一个函数
    try: # 尝试
        if a < b: # 如果a小于b
            raise BaseException(f'被减数{a}不能小于减数{b}') 
        else: #否则
            print(a - b) # 输出a-b
    except BaseException as f : #
        print(f) # 触发，抛出异常
Sub(4,5) # 第一个数4，第二个数是5

定义一个函数 Open(filename)，在函数中打开文件，并且返回文件内容，最后关闭， 用异常来处理可能发生的错误。

import os

def Open(filename): # 定义一个函数
    try: # 尝试
        fil = open("a.txt","r") # 打开一个文件，括号里的是文件的路径
    except Exception as err:
        print(err) # 输出异常
    else: # 否则
        print(fil.read()) # 读取文件内容
        fil.close() # 在程序不运行的时候删除
Open("fil") # 调用函数

写一个方法 Show(a, b, c)，判断三个参数是否能构成一个三角形，如果不能则抛出异常 IllegalArgumentException，显示异常信息 “a、b、c 不能构成三角形”，如果可以构成则显示三角形三个边长， 在方法中得到命令行输入的三个整数，调用此方法，并捕获异常。

class IIlegalAargumentException(Exception):
    pass

def Show(a,b,c):
	if a + b > c and a + c > b and b + c > a:
		print(a,b,c)
	else: 
		raise IIlegalAargumentException('不能构成三角形')

Show(3,4,5)
#Show(1,4,5)

定义一个函数Show(ls) ，ls = [133, 88, 24, 33, 232, 44, 11, 44]， 返回列表小于100，且为偶数的数。

def Show(ls):
    try:
        result = filter(lambda k: k < 100 and k % 2 == 0, ls)
    except Exception as ex:
        return ex
    else:
        return result

print(list(Show([133, 88, 24, 33, 232, 44, 11, 44])))

编写一个函数 Div(a, b)，实现 a 除以 b，先判断b是不是等于零，如果b等于零，抛出分母为零异常

def Div(a,b):
    if b == 0:
        raise Exception('分母为零')
    else:
        print(a / b)