Python基础概念（未完待续）

win10下安装python不生效，可以尝试菜单搜索【管理应用执行别名】关闭python相关的两个选项即可

1.Python的可变类型和不可变类型

不可变类型，内存中的数据不允许被修改，即修改此数据的值，则其引用地址就发生了变化

可变类型，可以通过变量名调用方法来修改列表和字典内部的内容，而内存地址不发生变化，可变类型（列表和字典）的数据变化，是通过方法（比如append,remove,pop等）来实现的，不会改变地址。而重新赋值后地址会改变。

可变如下，其他不可变

列表list

字典dict（注：字典中的key只能使用不可变类型的数据）

2.如何在python中定义一个函数，注意冒号必不可少

使用def关键字即可，例如

def function():

        执行内容

3.Python循环中的break、continue、pass使用详解

break用来跳出当前循环体，中止这个循环的运行

continue用来跳过这一次执行的后续操作，还会继续下一次循环

pass用来做为占位符，不做任何操作，因为一个没有任何操作的函数编译会报错

4.python中list(列表)和tuple(元组)的区别

4.1列表用方号[ ]定义；元组用圆括号( )定义。

4.2列表是可变的动态序列，可以访问，并增加、删除和修改列表中的元素，支持切片操作；元组是不可变的静态序列，可以访问、不可以增删改元组中的元素，同样支持切片操作。

4.3列表一经创建，长度仍可变化，所占的内存较大；元组一经创建，长度不可变化，直接被写死，所占的内存较小。

4.4由于元组是不可变、静态的，则其可以作为字典的键（key），具有可靠性。

5.什么是切片操作

字符串，列表，元组，可以使用切片操作截取某一部分

序列对象[start:stop:step] 切片开始的位置，结束的位置（不包含），步长

6.python中字典如何工作，有哪些常用方法

在Python中，字典是一种可变容器模型，可以存储任意类型对象。字典中的每个键值对（key=>value）都是用冒号(:)分割，每个键值对之间用逗号(,)分隔，整个字典则包含在花括号({})中。

dict.add(新增) pop(删除指定key的值)  popitem(删除最后一对键值) del(删除单个或全部)

dict.get() # 获取指定key的元素value

dict.keys() # 获取所有key

dict.values() # 获取所有value

dict.items() # 获取所有key-value

dict.copy() # 复制字典

dict.clear() # 清空字典

dict.update({key: new-value}) #更新字典指定键值对的value

7.如何使用集合（set）进行去重操作

Python的集合会自动去除重复数据

list1 = [1, 2, 2, 3, 4, 4, 5]

list1 = list(set(list1))

8.python中sort和sorted的异同

sort方法是列表（list）对象的方法，用于在原列表上进行排序，会改变原列表的元素顺序，并且没有返回值。

lst=[5,2,3,4]

lst.sort()        #升序排列

lst.sort(reverse=True) #降序排列

print(lst)

sorted方法是Python的内置函数，可以处理任何可迭代对象（如列表、元组、字典等）的排序，而不改变原列表的元素顺序，返回一个新的排序后的列表。

lst=[5,2,3,4]

new_lst=sorted(lst)        #升序排列

new_lst=sorted(lst,reverse=True) #降序排列

print(new_lst)

9.python的异常处理机制

try :

代码逻辑

except Exception as e:

打印报错信息e，无报错则不执行

finally :

不管有没有异常此处逻辑均执行，即使try里有return

10.请解释python中的类（class）和对象（object）的概念

类是对象的模板或蓝图，而对象是类的实例。

类是创建对象的模板。它定义了一个对象的属性和方法。属性是在对象中存储的数据，而方法是可以在对象上执行的操作。在Python中，使用class关键字定义类。

对象是类的实例，它具有类定义的属性和方法。在Python中，可以使用.操作符来访问对象的属性。例如：print(obj.attribute)  # 输出指定对象的值，对象的方法也是由类定义的。在Python中，也可以使用.操作符来调用对象的方法。例如：
obj.method()  # 输出method方法

11.如何定义和使用类的构造函数（_init_方法）

Init前缀和后缀是两个下划线 _，至少要包含一个 self 参数，self指向新创建的对象，构造函数主要用于初始化新创建的对象，为对象的各个属性赋值，并将其初始化为特定的值。它没有返回值（实测只可以返回None，但是不能返回其他类型），也不能用void来修饰。示例如下

class MyClass:  

    def __init__(self,attribute):  # 构造函数，在创建新对象时自动调用  

        self.attribute = attribute  # 属性定义

    def method(self):  # 方法定义  

        print(self.attribute,"This is a method")

        print(f"{self.attribute},This is a method")        

ex=MyClass("Hi")#创建一个实例

ex.method()#调用方法

12.什么是继承，在python中如何实现？

继承是指在一个类中可以使用另一个类中已有的属性和方法，这样可以减少代码的重复性，方便代码的维护和更新。在python中使用关键字class定义子类（派生类），并在其后的括号中指定父类（基类或超类）。子类会继承父类的所有公有（public）属性和方法。示例如下：

class Parent:

    def __init__(self):

        self.parent_attr = 1    

    def parent_method(self):

        print("This is a method of the Parent class.")

class Child(Parent):

    def __init__(self):

        Parent.__init__(self)  # 调用父类的初始化方法

        self.child_attr = 2    

    def child_method(self):

        print("This is a method of the Child class.")

child = Child()

print("out1=",child.parent_attr)  # 继承自父类

child.parent_method()     # 继承自父类

print("out2=",child.child_attr)   # 子类中定义的新属性

child.child_method()      # 子类中定义的新方法

13.如何使用python打开，读取和写入文件

import os

with open(“filename”,”mode”) as file:  #mode=r只读，mode=w只写，mode=a，追加模式，写入的内容追加到文件末行

Content = file.read() #读取文件

Content = file.readline()  #逐行读取文件

file.write(“hello”)  #将hello写入只写模式打开的文件

file.close() #关闭打开的文件

14.python中多线程和多进程的区别

进程是操作系统资源分配的基本单位，每个进程都有自己的内存空间和进程控制块，而线程是CPU调度和分派的基本单位，属于轻量级的进程，共享进程的资源，如代码段、数据段和打开的文件等。进程之间相对独立，资源隔离性好，但创建和销毁进程的开销较大，进程间通信比较复杂，需要特殊的机制，如队列、管道等；线程共享进程的资源，切换速度快，但同一进程下的线程之间不能共享内存，且由于Python中的全局解释器锁(GIL)的存在，限制了多线程的并行执行，在CPU密集型任务上并不能充分利用多核处理器。

15.如何使用python中的threading和multiprocessing模块

threading模块用于创建线程

import threading

def job():

print("Hello from a thread!")

# 创建线程

thread = threading.Thread(target=job)

# 启动线程

thread.start()

# 等待线程完成

thread.join()

multiprocessing模块用于创建进程

import multiprocessing

def job():

print("Hello from a process!")

# 创建进程

process = multiprocessing.Process(target=job)

# 启动进程

process.start()

# 等待进程完成

process.join()

16.python中的全局解释器锁（GIL）

在Python中，GIL是为了保证解释器线程安全而引入的。

GIL的作用是在解释器的执行过程中，确保同一时间只有一个线程可以执行Python字节码。这意味着在多线程的情况下，同一时刻只有一个线程可以真正地执行Python代码，其他线程只能等待。这是因为GIL会在解释器的关键部分进行加锁，阻止其他线程的执行。

可以使用多进程，使用并发库，使用替代python解释器等方式，避开GIL锁，提高线程效率（高I/O输出情况下）

17.python连接和操作数据库的经验

使用pymysql连接mysql，其他数据库使用的组件不同，但是原理和步骤是一样的，下面是一个插入前先对数据去重的样例

import pymysql

conn=pymysql.connect(host='ip',user='username',password='psw',db='daname',port=3306,charset='utf8')
    cursor = conn.cursor()
    try:

sqlvalues=[]
        repeatkey=[]
        dat= get_excel() #通过excel获取插入数据，封装好的函数
        now=datetime.datetime.now()-datetime.timedelta(days=1)
        stat_date=now.strftime('%Y-%m-%d')
        for i in dat:
            citycode=i.get('city_code')
            origin_lon6=i.get('origin_lon6')
            origin_lat6=i.get('origin_lat6')
            key = citycode+"_"+stat_date+"_"+str(origin_lon6)+"_"+str(origin_lat6)#此处可以自己制定条件进行去重校验
            if key not in repeatkey:
                repeatkey.append(key)
                sqlvalues.append((stat_date,citycode,i.get('city_name'),i.get('city_name_short'),i.get('mesh_id'),origin_lon6,origin_lat6))

sql = "insert into table (`stat_date`,`city_code`,`city_name`,`city_name_short`,`mesh_id`,`origin_lon6`,`origin_lat6`) values (%s,%s,%s,%s,%s,%s,%s)"
        cursor.executemany(sql,sqlvalues)
        conn.commit()
        print("成功入库数据条数：",str(len(sqlvalues)),flush=True)
    except Exception as e:
        #发生错误时回滚事务
        conn.rollback()
        print("入库错误",str(e),flush=True)
    finally:
        #关闭游标和连接
        cursor.close()
        conn.close()

18.python中的装饰器（decorator）及其用途

装饰器是一个可调用的对象，它接受一个函数作为参数，并返回一个函数作为结果。实际上，装饰器就是一个函数，但是它的作用不是直接运行函数，而是在运行函数之前或之后，对函数进行一些额外操作，如添加日志、缓存数据、验证权限等。

装饰器有自己特殊的语法，它使用"@"符号将装饰器名称放在函数声明的前面。可以让代码更加简洁、易于阅读维护

19.python中的生成器（generator）和迭代器（itrator）

迭代器，在Python指用类实现的服从迭代器协议的数据结构，即迭代器类定义了__iter__()方法和__next__()方法，使得该迭代器能够被for关键字迭代等等，其中：__iter__()方法返回一个迭代器对象，一般是self，这个返回的对象必须实现了__next__()方法，因为for循环使用这个迭代器时，会首先调用一次__iter__()，然后每次循环时调用这个__iter__()返回的对象的__next__()方法，将__next__()返回值赋给循环变量。当数据结构中的数据被遍历过一遍时，要__next__()负责抛出StopIteration异常，告诉for语句停止迭代。另外，关于一个迭代器对象可以迭代几次的问题。这个取决于抛出StopIteration异常前，是否有将这个迭代器对象的状态重置。如果没有重置，第一次for循环不会出现问题，第二次不会报错，但是for语句块没有循环。

生成器是一种特殊的迭代器，可以通过生成器表达式或生成器函数实现，每次循环会保存生成器当前的状态，下次循环时当前生成器中的状态推导下一个元素，生成器表达式指用用圆括号括住推导式，这个表达式可以返回一个迭代器对象