python实例代码介绍python基础知识

TODO: 知识点仍有待整理

import

使用 import 关键字可以让你选择性地导入所需的模块，而不必导入整个模块库。这样可以减少内存占用和加载时间，尤其是当你只需要使用模块中的某些功能时。

同时，使用 import 可以提高代码的可读性和可维护性，因为你可以明确指定所需的模块，而不必导入整个库。

另外，使用 import 还可以避免命名冲突。如果你导入整个库，可能会有一些与你自己的代码冲突的名称。但是，如果你只导入所需的模块，你可以更好地控制命名空间，避免冲突。

#!/usr/bin/env python3
#-*- coding: utf-8 -*-

# 开头都建议添加python解释器和编码声明
# 第一行注释是为了告诉 Linux/OS X 系统，这是一个 Python 可执行程序，Windows 系统会忽略这个注释
# 第二行注释是为了告诉 Python 解释器，按照 UTF-8 编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
# 申明了 UTF-8 编码并不意味着你的.py 文件就是 UTF-8 编码的，必须并且要确保文本编辑器正在使用 UTF-8 without BOM 编码
# 如果.py文件本身使用 UTF-8 编码，并且也申明了# -*- coding: utf-8 -*-，打开命令提示符测试就可以正常显示中文

# 运行脚本时带入参数，可以在main函数中用sys模块的argv获取参数值，len(sys.argv)获取参数个数
# 如果没带参数，len(sys.argv)默认是1，表示本身自带参数为当前脚本的完整路径
# 如：C:\Users\xxx\Desktop\PLCN1证书检查工具\PLCN1证书检查工具.py
#if __name__ == '__main__':
#    import sys
#    args = sys.argv, args[1]为带的第一个参数
#    argc = len(sys.argv)
import argparse

parser = argparse.ArgumentParser()
parser.add_argument("loc", type=str)
parser.add_argument('loc2', type=str, default="5555")
parser.add_argument('--b', type=int, default=0)
parser.add_argument('-n', "--number", type=str, help='输入一个数字')  --此时n是number的缩写，参数会存在number中，而不是n中
args = parser.parse_args()

print(args.loc, type(args.loc))
print(args.loc2, type(args.loc2))
print(args.b, type(args.b))
print(args.number, type(args.number))

# 执行python test.py  --b=1 --number=2 3 5


# 打印数据
info = " hello python "
print(info)
print("首字母大写输出:" + info.title())
print("全部大写输出:" + info.upper())
print("去除空格l-left,r-right,或两边空格:" + info.lstrip())
print('转义字符："打印有双引号，外面就用单引号，反过来同理"')
print("""打印可以用三引号
    三引号支持换行
    ！！！""")
print("\t这个是tab和回车 \n")
print_string_a = "string a"
print_int_b = 100
print(f'string a is: {print_string_a}, int b is : {print_int_b:.1f}')   # 类似于printf("a:%s,b:%.1f", a, b)
print("string a is: %s int b is:%d\n" % (print_string_a, print_int_b))
print(r'\t\n利用r参数这些转义字符不转义')
print(print_string_a.ljust(5,'*') + "用.ljust(5,*)表示左对齐并占五个空白字符空间,后面空格用*号替代,同理可以用.center表示居中对齐, .rjust右对齐")


# 字符串拼接
info1 = "hello"
info2 = "world"
combine_info = info1 + " " + info2
print(combine_info)

# 字符串判断，判断string是否是str开头的，返回从0开始的位置
string.startswith('str')


# 去空格及特殊符号

s.strip().lstrip().rstrip(',')
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。

# 复制字符串
#strcpy(sStr1,sStr2)
sStr1 = 'strcpy'
sStr2 = sStr1
sStr1 = 'strcpy2'
print sStr2

# 连接字符串
#strcat(sStr1,sStr2)
sStr1 = 'strcat'
sStr2 = 'append'
sStr1 += sStr2
print sStr1

# 查找字符
#strchr(sStr1,sStr2)
# < 0 为未找到
sStr1 = 'strchr'
sStr2 = 's'
nPos = sStr1.index(sStr2)
print nPos

# 比较字符串
#strcmp(sStr1,sStr2)
sStr1 = 'strchr'
sStr2 = 'strch'
print cmp(sStr1,sStr2)

# 扫描字符串是否包含指定的字符
#strspn(sStr1,sStr2)
sStr1 = '12345678'
sStr2 = '456'
#sStr1 and chars both in sStr1 and sStr2
print len(sStr1 and sStr2)

# 字符串长度
#strlen(sStr1)
sStr1 = 'strlen'
print len(sStr1)

# 将字符串中的大小写转换
#strlwr(sStr1)
sStr1 = 'JCstrlwr'
sStr1 = sStr1.upper()
#sStr1 = sStr1.lower()
print sStr1

# 追加指定长度的字符串
#strncat(sStr1,sStr2,n)
sStr1 = '12345'
sStr2 = 'abcdef'
n = 3
sStr1 += sStr2[0:n]
print sStr1

# 字符串指定长度比较
#strncmp(sStr1,sStr2,n)
sStr1 = '12345'
sStr2 = '123bc'
n = 3
print cmp(sStr1[0:n],sStr2[0:n])

# 复制指定长度的字符
#strncpy(sStr1,sStr2,n)
sStr1 = ''
sStr2 = '12345'
n = 3
sStr1 = sStr2[0:n]
print sStr1

# 将字符串前n个字符替换为指定的字符
#strnset(sStr1,ch,n)
sStr1 = '12345'
ch = 'r'
n = 3
sStr1 = n * ch + sStr1[3:]
print sStr1

# 扫描字符串
#strpbrk(sStr1,sStr2)
sStr1 = 'cekjgdklab'
sStr2 = 'gka'
nPos = -1
for c in sStr1:
  if c in sStr2:
    nPos = sStr1.index(c)
    break
print nPos

# 翻转字符串
#strrev(sStr1)
sStr1 = 'abcdefg'
sStr1 = sStr1[::-1]
print sStr1

# 查找字符串
#strstr(sStr1,sStr2)
sStr1 = 'abcdefg'
sStr2 = 'cde'
print sStr1.find(sStr2)

# 分割字符串
#strtok(sStr1,sStr2)
sStr1 = 'ab,cde,fgh,ijk'
sStr2 = ','
sStr1 = sStr1[sStr1.find(sStr2) + 1:]
print sStr1
#或者
s = 'ab,cde,fgh,ijk'
print(s.split(','))

# 连接字符串
delimiter = ','
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)

# 取关键字到末尾的字符串
start_pos=string.find('keyword')
f.write('%s\n' % string[start_pos:])

# 数字的字符化
age = 23
print("age:" + str(age) + " half is:" + str(23/2))    # 不加str会报错，py不知道是字符2和3，还是数字23，但是可以单独打印print(age)


# 列表（数组）
name = ["jane", "mike", "michael"]    # []内可为空内容
print(name)
print("列表元素0：" + name[0] + ", 最后一个元素：" + name[-1])    # 通过下标访问，-1表示最后一个元素，-2表示倒数第二个，以此类推

name[0] = "jane1"
print("修改后的name0元素：" + name[0])

name.append("append name")
print("添加元素后的列表：" + str(name))

name.insert(0, "insert name")
print("插入元素后的列表：" + str(name))

del name[0]
print("删除了元素0后的列表：" + str(name))
name.pop(0)    # pop和del可以认为是一个意思
print("删除了元素0后的列表：" + str(name))
name.remove("mike")
print("通过值mike来删除元素：" + str(name))

name.sort(reverse=True)
print("按字母逆排序元素：" + str(name))
name.sort()    # sort会永久修改列表
print("按字母排序元素：" + str(name))
print("临时排序：" + str(sorted(name, reverse=True)))    # sorted只会临时修改元素顺序，执行后name还是会恢复原来顺序
print("还是原来的顺序:" + str(name))

name.insert(0, "mike")
name.reverse()
print("逆序输出:" + str(name))

print("列表长度：" + str(len(name)))

num_list = list(range(0, 6))
print("数字转列表：" + str(num_list))

print("取范围内的元素：" + str(num_list[1:3]))    # 从num_list[1]开始取值，取3-1个
print("取范围内的元素：" + str(num_list[:3]))    # 从开始取值，取3-0个

copy_name = name
print("列表可以直接赋值，但是如果修改了name或copy_name，都会导致两个变量值的改变\n")
copy1_name = name[:]
print("通过类似切片:的方式，可以创建副本并给赋值的变量，这样就是两个独立的变量了\n")

if name:
    print("列表不为空")
else:
    print("列表是空的")

# for循环的使用
students = ["stu1", "stu2", "stu3"]
for stu in students:    # 赋值给stu，并打印
    print(stu)
print("缩进代表着该行的代码与上一个未缩进的行的代码是一起的\n")

for value in students[0:2]:
    print(value)

# 不用变量，只要循环
for _ in range(3, num_params):
    pattern = pattern + r',\s*(.*)'

# 元组（不可修改的数组）
dimensions = (1, 2, 3, 4, 5)
print(dimensions)
print(dimensions[0])
# dimensions[0] = 2 # 这样将提示出错
dimensions = (6, 7, 8, 9)    # 不能改元素值，但是可以重新赋值变量
print(dimensions)


# if条件语句的使用
cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
    if car == 'bmw':    # 不等于用 !=，如果多个条件就用 and/or/ ，(a==a) and (b==b)
        print(car.upper())
    else:
        print(car.title())

if 'audi' not in cars:    # not的用法
    print("audi not in cars\n")
elif 'bmw' in cars:
    print("bmw in cars\n")
else:    # 可以不用
    print()

# 一个顾客点披萨加配料检查的例子
available_toppings = ['mushrooms', 'olives', 'green peppers', 'pepperoni', 'pineapple', 'extra cheese']
requested_toppings = ['mushrooms', 'french fries', 'extra cheese']
for requested_topping in requested_toppings:
    if requested_topping in available_toppings:
        print("Adding " + requested_topping + ".")
    else:
        print("Sorry, we don't have " + requested_topping + ".")
print("\nFinished making your pizza!")


# 字典，类似二维数组
bike_0 = {'color': 'red', 'price': '1000'}
print("bike 0 color is: " + bike_0['color'])

bike_0['size'] = 100
print("添加键值对：" + str(bike_0))

bike_0['size'] = 50
print("修改字典值：" + str(bike_0))

del bike_0['size']
print("删除字典值size：" + str(bike_0))

# 注意，即便遍历字典时，键—值对的返回顺序也与存储顺序不同。 Python不关心键—值对的存储顺序，而只跟踪键和值之间的关联关系
print("遍历字典")
for key, value in bike_0.items():
    print("key: " + key + " value: " + value)
for name in bike_0.keys():
    print(".key方式获取关键字：" + name)
for name in bike_0.values():
    print(".values方式获取值：" + name)

bike_1 = {'color': 'blue', 'price': '500'}
bikes = [bike_0, bike_1]
print("字典嵌套")
for bike in bikes:
    print(bike)

# 在字典中存储列表
bike_3 = {
    'size': '100',
    'color': ['yellow', 'white']    # 这就是列表
}
for bike_3_color in bike_3['color']:
    print("bike_3 color: " + bike_3_color)

# 也有字典中嵌套字典的，这个稍复杂一点点，举个例子好了
users = {
    'user1': {
        'first': 'albert',
        'last': 'einstein',
        'location': 'princeton',
    },
    'user2': {
        'first': 'marie',
        'last': 'curie',
        'location': 'paris',
    },
}
for username, user_info in users.items():
    print("\nUsername: " + username)
    full_name = user_info['first'] + " " + user_info['last']
    location = user_info['location']
    print("\tFull name: " + full_name.title())
    print("\tLocation: " + location.title())


# 用户输入数据
# input输入时默认就是字符串，要变成数字需要转化处理
# age = input("please tell me your age: ")
age = '100'
print("your age is: " + age)
age = int(age)    # float也是类似用法
print("当前age是数字：" + str(age))
# test_num = int(input('input num:'))  # 也可以输入时指定类型


# while循环用法
current_number = 1
while current_number <= 5:
    print(current_number)
    current_number += 1
    if current_number > 3:
        break
    else:
        continue


# 函数用法
def greet(username, user_age=50):
    """ 三个双引号表示函数功能描述,Python使用它们来生成有关程序中函数的文档 """
    # 井号也是可以用的
    print("函数用法：hello " + username + " age: " + str(user_age))
    return True


ret = greet('mike', 100)
ret = greet(username='mike', user_age=100)
ret = greet(user_age=100, username='mike')  # 指名形参，就可以不按照顺序赋值

# 传递任意数量的实参，有点像指针
def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)
    make_pizza('pepperoni')
    make_pizza('mushrooms', 'green peppers', 'extra cheese')


def make_pizza_2(size, *toppings):
    """概述要制作的比萨"""
    print("\nMaking a " + str(size) +
    "-inch pizza with the following toppings:")
    for topping in toppings:
        print("- " + topping)
make_pizza_2(16, 'pepperoni')
make_pizza_2(12, 'mushrooms', 'green peppers', 'extra cheese')


# 将函数存储在模块中
# 将函数存储在独立文件中后，可与其他程序员共享这些文件而不是整个程序
# 比如将制作披萨的函数make_pizza()放在pizza.py中
# 新建making_pizza.py，在第一行通过import pizza,就可以导入模块，再通过pizza.make_pizza()进行调用

# 也可以导入模块中指定的函数,包括多个函数
# 通过 from pizza import make_pizza1, make_pizza2 来实现，调用时直接用函数 make_pizza() 调用

# 导入的函数名和现有的名称有冲突怎么办？
# 通过导入时用as解决，具体如下：
# from pizza import make_pizza as mp
# 调用时：mp()

# as同样可以给模块起别名，如下：
# from pizza as p
# 调用时：p.make()

# 导入模块中的所有函数
# from pizza import *


# 类的使用
class Human:  # 类的首字母是大写
    """人类动作"""
    """__init__()是一个特殊的方法，每当你根据Dog类创建新实
例时， Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约
定，旨在避免Python默认方法与普通方法发生名称冲突。
我们将方法__init__()定义成了包含三个形参： self、 name和age。在这个方法的定义中，形
参self必不可少，还必须位于其他形参的前面。为何必须在方法定义中包含形参self呢？因为
Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。每个与类相关联的方法
调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
我们创建Dog实例时， Python将调用Dog类的方法__init__()。我们将通过实参向Dog()传递名字和
年龄； self会自动传递，因此我们不需要传递它。每当我们根据Dog类创建实例时，都只需给最
后两个形参（ name和age）提供值。"""
    def __init__(self, human_name, human_age):
        """初始化属性name和age"""
        self.human_name = human_name
        self.human_age = human_age
        # 类中的每个属性都必须有初始值，哪怕这个值是0或空字符串
        self.country = ""
        self.weight = 65

    def sit(self):
        print(self.human_name.title() + " is now sitting")

    def run(self):
        print(self.human_name.title() + " is running")

    def read_country(self):
        print("country is: " + self.country)

    def update_weight(self, weight):
        self.weight = weight

    def read_weight(self):
        print("weight is: " + str(self.weight))

"""
遇到这行代码时， Python使用实参'mike'和100，调用Human类中的方法__init__()。
方法__init__()创建一个表示特定人的示例，并使用我们提供的值来设置属性human_name和human_age。
方法__init__()并未显式地包含return语句，但Python自动返回一个表示这个人的实例。我们将这个实例存储在变量man1中。
"""
man1 = Human("mike", 100)
print("man name is: " + man1.human_name + ", age: " + str(man1.human_age))
# 调用类的方法
man1.sit()
man1.run()

man1.read_country()
man1.country = "china"
man1.read_country()

man1.read_weight()
man1.update_weight(70)
man1.read_weight()


# 类的继承
"""
编写类时，并非总是要从空白开始。如果你要编写的类是另一个现成类的特殊版本，可使用
继承。一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，
而新类称为子类。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。

创建子类的实例时， Python首先需要完成的任务是给父类的所有属性赋值。为此，子类的方
法__init__()需要父类施以援手。
"""


class AutoCar:
    """一次模拟汽车的简单尝试"""
    def __init__(self, make, model, year):
        self.make = make
        self.model = model

        self.year = year
        self.odometer_reading = 0

    def get_descriptive_name(self):
        long_name = str(self.year) + ' ' + self.make + ' ' + self.model
        return long_name.title()

    def read_odometer(self):
        print("This car has " + str(self.odometer_reading) + " miles on it.")

    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")

    def increment_odometer(self, miles):
        self.odometer_reading += miles


class Battery1:
    """电瓶的属性"""
    def __init__(self, battery_size1=70):
        self.battery_size1 = battery_size1

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size1) + "-kWh battery.")


class ElectricCar(AutoCar):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """初始化父类的属性"""
        # 给父类的所有属性赋值,必须执行，通过super实现初始化,父类也称为超类（ superclass），名称super因此而得名
        super().__init__(make, model, year)
        # 接下来定义电动汽车子类特有的属性
        self.battery_size = 70
        # 如果类的属性或方法太多，可以拎出来封装成新的类，然后再赋值给原来类的属性
        self.battery1 = Battery1()

    def show_battery_size(self):
        print("battery size: " + str(self.battery_size))

    # 父类的方法也是可以重写的，但是要和父类里面的方法名一样，比如重写read_odometer
    def read_odometer(self):
        print("can not read_odometer")


my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.show_battery_size()

# 如果类的属性或方法太多，可以拎出来封装成新的类，然后再赋值给原来类的属性
my_tesla.battery1.describe_battery()


# 类的模块化
# 和函数的模块化一样，比如在car.py中添加了一个类Car，在my_car.py中通过以下代码就可以导入
# from car import Car
# 使用时就用：my_new_car = Car('bmw', '525li', 2022)
# 类模块也可以导入其他的类模块


# 文件操作与异常
# 读出全部内容
with open('read_write_test_file/file_read.txt') as file_object:
    content = file_object.read()
    print("read file, content: \n"+ content)
    # 只管用with open打开，不用close关闭，python会自己确定关闭的时机
    # file_object.close()
    """
    虽然没有close，但下面不能再用file_object了，估计是因为python已经把文件关了，读出来都是空的
    for line in file_object:
        print(line.rstrip())
    """
#删除文件和目录,删除目录需要导入import shutil
if os.path.isdir(cert_path):
    shutil.rmtree(cert_path)
    print("delete " + cert_path)
if os.path.isfile(expired_list_file):
    os.unlink(expired_list_file)
    print("delete " + expired_list_file)

# 逐行读取
with open('read_write_test_file/file_read.txt') as file_object:
    for line in file_object:
        print(line.rstrip())

# 逐行读取到列表中
with open('read_write_test_file/file_read.txt') as file_object:
    lines = file_object.readlines()

for line in lines:
    print(line)  # 可以用rstrip去掉空行

# 读取超大文件，python对文件大小没有限制，只要内存够，多大数据都可以

# 判断文件中是否包含某个关键字
with open('read_write_test_file/file_read.txt') as file_object:
    lines = file_object.readlines()

file_string = ""
for line in lines:
    file_string += line.rstrip()

print(lines)
print(file_string)
keyword = "123"
if keyword in file_string:
    print("yes, appears in the file ")
else:
    print("no, not appears in the file")

# 写入文件
with open('read_write_test_file/file_read.txt', 'a') as file_object:
    file_object.write("\nwrite words")
with open('read_write_test_file/file_read.txt') as file_object:
    content = file_object.read()
    print(content)


# 异常，try-except代码块的使用
try:
    print(5/0)
except ZeroDivisionError:
    print("You can't divide by zero!")
    # 如果不提示错误信息，让用户感知不到，就用pass语句代替打印，如下：
    # pass

# 举个文件不存在的例子
try:
    with open('file_name') as f_obj:
        contents = f_obj.read()
# 这边知道错误的类型是FileNotFoundError，如果不知道错误的类型名，不能随便写，否则会报错，可以直接写except Exception:
except FileNotFoundError:
    msg = "Sorry, the file does not exist."
    print(msg)


# 让用户选择文件作为路径
    import tkinter as tk
    from tkinter import filedialog
    # 实例化
    root = tk.Tk()
    root.withdraw()
    # 获取文件夹路径
    xls_file = filedialog.askopenfilename()
    print('\n获取的文件地址：', xls_file)

# 解压和压缩tar gz文件
import os
import tarfile
import gzip

# 一次性打包整个根目录。空子目录会被打包。
# 如果只打包不压缩，将"w:gz"参数改为"w:"或"w"即可。
def make_targz(output_filename, source_dir):
    with tarfile.open(output_filename, "w:gz") as tar:
        tar.add(source_dir, arcname=os.path.basename(source_dir))

# 逐个添加文件打包，未打包空子目录。可过滤文件。
# 如果只打包不压缩，将"w:gz"参数改为"w:"或"w"即可。
def make_targz_one_by_one(output_filename, source_dir):
    tar = tarfile.open(output_filename, "w:gz")
    for root, dir, files in os.walk(source_dir):
        for file in files:
            pathfile = os.path.join(root, file)
            tar.add(pathfile)
    tar.close()


def un_gz(file_name):
    """ungz zip file"""
    f_name = file_name.replace(".gz", "")
    # 获取文件的名称，去掉
    g_file = gzip.GzipFile(file_name)
    # 创建gzip对象
    open(f_name, "wb+").write(g_file.read())
    # gzip对象用read()打开后，写入open()建立的文件里。
    g_file.close()  # 关闭gzip对象


def un_tar(file_name):
    # untar zip file
    tar = tarfile.open(file_name)
    names = tar.getnames()
    if os.path.isdir(file_name + "_files"):
        pass
    else:
        os.mkdir(file_name + "_files")
    # 由于解压后是许多文件，预先建立同名文件夹
    for name in names:
        tar.extract(name, file_name + "_files/")
    tar.close()


if __name__ == '__main__':
    make_targz('test.tar.gz', "E:python_samplelibs")
    make_targz_one_by_one('test01.tgz', "E:python_samplelibs")
    un_gz("test.tar.gz")
    un_tar("test.tar")

# 弹窗
# 先安装win32api模块：pip install pywin32
import win32api
import win32con

info = '弹窗'
print(info)
win32api.MessageBox(None, info, "提示", win32con.MB_OK)