python基础

Python基础

一、前序

1. 查看Python版本

   pyhton -V 或 Python --version

二、基础部分

2.1 基础语法

1. 编码

   默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

   # -*- coding: cp-1252 -*-
   

2. 标识符

   • 第一个字符必须是字母或下划线
   • 标识符的其他部分由字母，数字和下划线组成
   • 标识符对大小写敏感

3. python保留字

   >>> import keyword
   >>> keyword.kwlist
   ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
   

2.2 基本数据类型

标准数据类型

• Number 数字
• String 字符串
• bool 布尔类型
• List 列表
• Tuple 元组
• Set 集合
• Dictionary 字典

python3中六个标准数据类型中：

• 不可变数据（3个）：Number String Tuple
• 可变数据（3个）： List Dictionary Set

3.2.1 Number 数字

支持 int、float、bool、complex

内置的type()函数可以用来查询变量所指的对象类型

isinstance和type的区别：

• type（）不会认为子类是一种父类类型
• isinstance（）会认为子类时一种父类类型

3.2.2 String 字符串

字符串截取的语法如下：

变量[头下表 : 尾下标]

• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义
• Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始
• Python中的字符串不能改变

3.2.3 bool 布尔类型

• 布尔类型只有两个值：True 和 False。
• bool 是 int 的子类，因此布尔值可以被看作整数来使用，其中 True 等价于 1。
• 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
• 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。

3.2.4 列表

更新列表

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')

删除列表

使用del语句来删除列表中的元素：

#!/usr/bin/python3
 
list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

列表常用方法

• len(list) 列表元素个数
• list(seq) 将元组转换为列表
• list.count(obj) 统计某个元素在列表中出现的次数
• list.append(obj) 在列表中末尾添加新的对象
• list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值
• list.insert(obj) 从列表中找出某个值第一个匹配项的索引位置
• list.insert(index,obj) 将对象插入列表

三、异常

使用try-catch处理

try:
    #[代码块A] 可能会出现异常的代码
except  Exception1 [as 2]:
    # 异常处理
.....
[else:]
	# 可选，如果没有引发异常会执行
[finally：]
	# 无论如何都要执行的语句
    # 数据的清楚，文件流的关闭等操作

raise关键字

try:
    pwd = input('请输入您的密码：')
    if len(pwd) < 8:
        raise Exception('密码长度不够，请输入一个8位以上的密码')
except Exception as e:
    print(e) # 密码长度不够，请输入一个8位以上的密码

当能预期到可能出现异常时选择捕获异常，否则抛出异常

四、模块

使用import导入

from 模块名 import 方法名  as 别名

每一个扩展名py结尾的python源文件都是一个模块

在模块中定义的全局变量，函数都是模块能够提供给外界使用的工具

1. 包的使用

   包是python模块的一种组织形式，将多个模块组合在一起，形成了一个大的python工具库。包通常是一个拥有__init__.py文件的目录，它定义了包的属性和方法。

   import  pack1.module1
   from pack1 import module1
   

2. 常见的标准库

   

3. time库

   • 获取当前时间

     • time.time(): 返回自纪元（1970年1月1日00:00:00 UTC）以来的秒数，通常称为Unix时间戳。

     • time.localtime(): 返回一个表示本地时间的time.struct_time对象。

     • time.gmtime(): 返回一个表示协调世界时（UTC）的time.struct_time对象。

       import time
       
       # 获取当前时间戳
       timestamp = time.time()
       print("当前时间戳:", timestamp)
       
       # 获取本地时间
       local_time = time.localtime()
       print("本地时间:", local_time)
       
       # 获取UTC时间
       utc_time = time.gmtime()
       print("UTC时间:", utc_time)
       
       
       #当前时间戳: 1715833304.1631322
       #本地时间: time.struct_time(tm_year=2024, tm_mon=5, tm_mday=16, tm_hour=12, tm_min=21, tm_sec=44, tm_wday=3, tm_yday=137, tm_isdst=0)
       #UTC时间: time.struct_time(tm_year=2024, tm_mon=5, tm_mday=16, tm_hour=4, tm_min=21, tm_sec=44, tm_wday=3, tm_yday=137, tm_isdst=0)
       

   • 时间格式化

     • time.strftime(format, time_tuple): 将time.struct_time对象格式化为字符串。

     • time.strptime(string, format): 将字符串解析为time.struct_time对象。

       import time
       
       # 格式化本地时间
       formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
       print("格式化后的本地时间:", formatted_time)
       
       # 解析时间字符串
       parsed_time = time.strptime("2021-09-10 10:22:47", "%Y-%m-%d %H:%M:%S")
       print("解析后的时间:", parsed_time)
       
       #格式化后的本地时间: 2024-05-16 12:22:02
       #解析后的时间: time.struct_time(tm_year=2021, tm_mon=9, tm_mday=10, tm_hour=10, tm_min=22, tm_sec=47, tm_wday=4, tm_yday=253, tm_isdst=-1)
       

   • 延时执行

     • time.sleep(seconds): 使程序暂停指定的秒数。

       import time
       
       print("开始休眠...")
       time.sleep(2)  # 休眠2秒
       print("休眠结束!")
       

   • 定时器（每隔一定时间执行一次任务）

     使用 time.sleep() 和一个循环来创建一个简单的定时器。

     import time
     
     def timer_task():
         print("定时任务执行中...")
     
     while True:
         timer_task()
         time.sleep(5)  # 每5秒执行一次
     
     # 注意：上面的代码会无限循环，你可能需要一种方式来中断它，比如设置一个标志变量或使用try/except捕获KeyboardInterrupt异常。
     

   • 获取时间戳的日期部分

     import time
     from datetime import datetime
     
     timestamp = time.time()
     dt_object = datetime.fromtimestamp(timestamp)
     date_only = dt_object.date()
     print("日期部分:", date_only)
     

五、面向对象

5.1 类和实例

定义类

• object 父类的名字，默认是object，所有的类都直接或间接的继承object类

  class ClassName(object):
      .....
  

实例

实例名 = 类名()

class Player(object):
    numbers = 0  # 类属性 （共用的属性）

    # 构造函数
    def __init__(self, name, age, addr):
        self.name = name  # 实例属性
        self.__age = age  # 私有变量
        self._addr = addr  # 受保护的

        # 使用类属性
        Player.numbers += 1
    '''
        把函数当做变量使用
            @Property
                获取变量
            @变量名.setter
                设置变量
    '''

    @property  # 获取变量
    def age(self):
        return self.__age

    @age.setter  # 修改变量
    def set_age(self, age):
        if isinstance(age, int):
            self.__age = age

    def show_info(self):
        print('大家好我叫{},我今年{}岁了'.format(self.name, self.age))

    # 类方法
    @classmethod
    def class_method(cls):
        try:
            print("我是一个类方法" + cls.numbers)
            raise Exception("数值不能和字符串拼接")
        except Exception as e:
            print(e)

    @classmethod
    def show_dict(cls):
        dic = {'1': {'name': '张三', 'age': 13}, '2': {'name': '李四', 'age': 18}}
        for k, v in dic.items():
            print(k, v)

    # 静态方法
    @staticmethod
    def isvalid(age_dict):
        if 'age' in age_dict and age_dict['age'] >= 18:
            return True
        return False


age = {'age': 24}
if Player.isvalid(age):
    mia = Player('mia', 24, '广东')
    mia.show_info()

    # 获取对象的所有属性  不能获取类属性
    print(mia.__dict__)
    mia.show_dict()
    print(mia.age)
    mia.age = 30
    print(mia.age)
else:
    print("创建失败")

魔方函数

1. __init__() 实例化对象的时候该方法被调用
2. __str__() 定义当使用str打印对象时显示的内容
3. __eq__() 判断两个对象是否相等

六、多线程

python3 线程中常用的两个模块为：

• _thread
• threading(推荐使用)

python 中使用线程有两种方式：函数或者用类来包装线程对象

函数式：调用_thread模块中的start_new_thread() 函数来产生新线程

_thread.start_new_thread ( function, args[, kwargs] )

参数说明:

• function - 线程函数。
• args - 传递给线程函数的参数,他必须是个tuple类型。
• kwargs - 可选参数。

#!/usr/bin/python3

import _thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
   count = 0
   while count < 5:
      time.sleep(delay)
      count += 1
      print ("%s: %s" % ( threadName, time.ctime(time.time()) ))

# 创建两个线程
try:
   _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
   _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
except:
   print ("Error: 无法启动线程")

while 1:
   pass

线程模块

Python3 通过两个标准库 _thread 和 threading 提供对线程的支持。

_thread 提供了低级别的、原始的线程以及一个简单的锁，它相比于 threading 模块的功能还是比较有限的。

threading 模块除了包含 _thread 模块中的所有方法外，还提供的其他方法：

• threading.current_thread(): 返回当前的线程变量。

• threading.enumerate(): 返回一个包含正在运行的线程的列表。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。

• threading.active_count(): 返回正在运行的线程数量，与 len(threading.enumerate()) 有相同的结果。

• threading.Thread(target, args=(), kwargs={}, daemon=None)

  ：

  • 创建Thread类的实例。
  • target：线程将要执行的目标函数。
  • args：目标函数的参数，以元组形式传递。
  • kwargs：目标函数的关键字参数，以字典形式传递。
  • daemon：指定线程是否为守护线程。

threading.Thread 类提供了以下方法与属性:

1. __init__(self, group=None, target=None, name=None, args=(), kwargs={}, \*, daemon=None)：
   • 初始化Thread对象。
   • group：线程组，暂时未使用，保留为将来的扩展。
   • target：线程将要执行的目标函数。
   • name：线程的名称。
   • args：目标函数的参数，以元组形式传递。
   • kwargs：目标函数的关键字参数，以字典形式传递。
   • daemon：指定线程是否为守护线程。
2. start(self)：
   • 启动线程。将调用线程的run()方法。
3. run(self)：
   • 线程在此方法中定义要执行的代码。
4. join(self, timeout=None)：
   • 等待线程终止。默认情况下，join()会一直阻塞，直到被调用线程终止。如果指定了timeout参数，则最多等待timeout秒。
5. is_alive(self)：
   • 返回线程是否在运行。如果线程已经启动且尚未终止，则返回True，否则返回False。
6. getName(self)：
   • 返回线程的名称。
7. setName(self, name)：
   • 设置线程的名称。
8. ident属性：
   • 线程的唯一标识符。
9. daemon属性：
   • 线程的守护标志，用于指示是否是守护线程。
10. isDaemon()方法：

import threading
import time

def print_numbers():
    for i in range(5):
        time.sleep(1)
        print(i)

# 创建线程
thread = threading.Thread(target=print_numbers)

# 启动线程
thread.start()

# 等待线程结束
thread.join()

使用threading模型创建线程

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.delay, 5)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")