Python基础语法

已于 2023-05-10 13:20:14 修改
阅读量409 收藏
点赞数
分类专栏： python基础 文章标签： python 开发语言
于 2023-03-12 15:45:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51714391/article/details/129460829
版权

python基础语法

变量及注释

变量

  • 标识：表示对象所存储的内存地址，使用内置函数id来获取
  • 类型：表示的是对象的数据类型，使用内置函数type来获取
  • 值：表示对象所存储的具体数据，使用print可以打印输出
name = "gq"
print("标识",id(name))
print("类型",type(name))
print("值",name)

在这里插入图片描述

注释

  • 单行注释 #
  • 多行注释 "’ "’

数据类型

整数–> int

可以表示正数、负数、0

浮点–>float

  • 浮点数由整数部分和小数部分组成
  • 浮点数目进行计算时，可能会出现小数位数不确定的情况
from decimal import Decimal
print(1.1 + 2.2) #3.3000000000000
print(Decimal('1.1') + Decimal('2.2')) #3.3

布尔–>bool

  • True用来表示真，False用来表示假
  • 布尔可以转化为整数
print(True + 1) #2
print(False + 1) #1

字符串–>str

数据类型转换

在python中，不同数据类型不可以连接在一起

name = ‘gq’
age = 23
print(‘我叫’ + name + '今年' + age + '岁') # 会报错
print(‘我叫’ + sname + '今年' + str(age) + '岁') # 不报错

在python中数据类型转换如下：

函数名作用注意举例
str()将其他函数转换为字符串也可以进行引号转换str(123) 、str(False)
int()将其他类型转化为整数文字形式无法转换、浮点类型会抹掉小数int(‘123’)
float()将其他类型转换为浮点文字形式无法转换、整数转化为浮点后面加0float(‘9.9’)

运算符

算数运算符

# + - * / 加减乘除
# // 整除 ； % 取余运算符； ** 幂运算符
print(11 // 2) # 5
print(11 % 2) # 1
print(2**3) # 8

赋值运算符

print("支持链式赋值")
a = b = c = 20 
print("支持参数赋值")
a = 20
a += 30
a -= 10
a //= 2
a %= 2
print("支持解包赋值")
a, b, c = 10, 20, 30

比较运算符

比较运算符的结果为布尔类型
常见的：< > <= >= !=
比较对象的值 ：==
比较对象的标识（地址）： is is not

布尔运算符

在这里插入图片描述

位运算符

在这里插入图片描述在这里插入图片描述

print(4<<1) #向左移动一位，相当于乘以2
print(4<<2) #向左移动一位，相当于乘以4
print(4>>1) #向右移动一位，相当于除以2
print(4>>2) #向右移动二位，相当于除以4

运算符的优先级

优先级由高到低：
算术运算符–》位运算符–》比较运算符–》布尔运算符–》赋值运算符
在这里插入图片描述

流程控制语句

对象的布尔值

以下对象的布尔值为False

  • False
  • 数值0
  • None
  • 空字符串
  • 空列表
  • 空元组
  • 空集合
  • 空字典
  • 空集合

if 以及if else

多分支if

a = 10
if a == 1:
	pass
elif a == 2:
	pass
elif a == 3:
	pass
else:
	print('a = 10')

嵌套if

a = 10
b = 20
if a == 10:
	if b == 20:
		print("a = 10, b = 20")
	else:
		print("a = 10, b!= 20")
else:
	print("**")

if else 的条件表达式

# 语法结构 x  if  判断条件 else y 
# 若判断条件为True，则条件表达式返回值为x，反之为y
a = 10
b = 20
c = a if a < b else b
print(c) # c= 10

while 以及 while else

a = 0
while a < 5:
	a += 1
	if (a == 3):
		break
print(a) # 3



while a < 5:
	a+=1
else:
	print("while 循环结束")

for 以及 for else

for item in range(10):
	if item == 3:
		break
print(item) #3 


for item in range(10):
	if item == 3;
		break
else:
	print("for循环结束")

数据结构

列表

列表创建与删除

#列表的创建
a = [100,'gq',True]
a = list([100,'gq',True])

在Python中，列表（list）提供了多种删除元素的方法，具体如下：

del语句：del语句可以删除指定位置的元素或整个列表。例如，del myList[0]可以删除列表中的第一个元素，而del myList可以删除整个列表。

pop()方法：pop()方法可以删除指定位置的元素，并返回被删除的元素。例如，myList.pop(0)可以删除列表中的第一个元素，并返回它。

remove()方法：remove()方法可以删除指定值的元素，如果有多个相同的元素，则只删除第一个。例如，myList.remove(3)可以删除列表中的值为3的元素。

clear()方法：clear()方法可以删除整个列表中的所有元素。例如，myList.clear()可以删除列表中的所有元素。

需要注意的是，在使用pop()和remove()方法时，如果要删除的元素不存在，会引发ValueError异常。同时，如果要删除的元素存在多个，pop()和remove()方法只会删除第一个匹配的元素。

列表查询操作

下标查询：使用下标可以查询列表中的元素，例如，myList[0]可以查询列表中的第一个元素。

切片查询：使用切片可以查询列表中的一个子序列。例如，myList[1:4]可以查询列表中第2到第4个元素，但不包括第5个元素。

in运算符：使用in运算符可以判断一个元素是否存在于列表中。例如，3 in myList可以判断列表中是否存在值为3的元素。

index()方法：index()方法可以查找指定值的元素在列表中的位置，并返回该位置的下标。例如，myList.index(3)可以查找值为3的元素在列表中的位置。

count()方法：count()方法可以统计指定值在列表中出现的次数，并返回出现的次数。例如，myList.count(3)可以统计值为3的元素在列表中出现的次数。

需要注意的是，在使用index()方法时，如果要查找的元素不存在，会引发ValueError异常。同时，在使用in运算符时，可以使用not in运算符来判断一个元素是否不存在于列表中。

列表元素的增删改操作

添加元素：可以使用append()方法向列表末尾添加一个元素。例如，myList.append(4)可以向列表中添加值为4的元素。

插入元素：可以使用insert()方法在列表中的指定位置插入一个元素。例如，myList.insert(1, 3)可以在列表的第二个位置插入值为3的元素。

删除元素：可以使用remove()方法删除列表中指定值的元素。例如，myList.remove(3)可以删除列表中值为3的元素。

修改元素：可以通过索引或切片的方式修改列表中的元素。例如，myList[0] = 1可以将列表中的第一个元素修改为1。

扩展列表：可以使用extend()方法将另一个列表中的元素添加到当前列表中。例如，myList.extend([5,6,7])可以将列表[5,6,7]中的元素添加到当前列表的末尾。

需要注意的是，如果要修改或删除的元素不存在，会引发IndexError或ValueError异常。另外，使用insert()方法时，如果插入的位置超过了列表的长度，元素将被插入到列表末尾。

列表元素的排序

sort()方法：sort()方法可以将列表中的元素按升序排列，也可以通过reverse=True参数将其改为降序排列。例如，myList.sort()可以将列表中的元素按升序排列，而myList.sort(reverse=True)可以将其改为降序排列。

sorted()函数：sorted()函数可以对列表中的元素进行排序，并返回一个新的排序后的列表。例如，sortedList = sorted(myList)可以返回一个新的升序排列后的列表。

reverse()方法：reverse()方法可以将列表中的元素倒序排列。例如，myList.reverse()可以将列表中的元素倒序排列。

需要注意的是，sort()方法和reverse()方法会直接修改原始列表，而sorted()函数会返回一个新的排序后的列表，不会修改原始列表。同时，sort()方法和sorted()函数可以通过key参数指定排序的关键字，例如，myList.sort(key=len)可以按照列表中元素的长度进行排序

列表推导式

myList = [1, 2, 3, 4, 5]
newList = [x**2 for x in myList]
print(newList)  # [1, 4, 9, 16, 25]

myList = ['apple', 'banana', 'orange']
newList = [x.upper() for x in myList]
print(newList)  # ['APPLE', 'BANANA', 'ORANGE']

myList = [1, 2, 3, 4, 5]
newList = [x for x in myList if x % 2 == 0]
print(newList)  # [2, 4]

元组

元组的创建方式

直接使用小括号创建元组：

myTuple = (1, 2, 3, 'apple', 'banana')
print(myTuple)  # (1, 2, 3, 'apple', 'banana')

使用tuple()函数将其他序列类型转换为元组：

myList = [1, 2, 3, 'apple', 'banana']
myTuple = tuple(myList)
print(myTuple)  # (1, 2, 3, 'apple', 'banana')

如果元组只包含一个元素，需要在元素后面添加一个逗号：

myTuple = ('apple',)
print(type(myTuple))  # <class 'tuple'>

使用解包操作符*将列表或其他可迭代对象转换为元组：

myList = [1, 2, 3]
myTuple = (*myList,)
print(myTuple)  # (1, 2, 3)

元组的遍历

#使用for循环遍历元组中的元素：
myTuple = (1, 2, 3, 'apple', 'banana')
for item in myTuple:
    print(item)

#使用enumerate()函数同时遍历元组中的元素和索引：
myTuple = (1, 2, 3, 'apple', 'banana')
for index, item in enumerate(myTuple):
    print(index, item)

#使用zip()函数将多个元组并行遍历：
myTuple1 = (1, 2, 3)
myTuple2 = ('apple', 'banana', 'orange')
for item1, item2 in zip(myTuple1, myTuple2):
    print(item1, item2)

字典

字典的创建与删除

创建字典：可以使用花括号{}或dict()函数来创建一个字典。例如：

# 使用花括号创建字典
myDict = {'name': 'Alice', 'age': 20, 'city': 'New York'}

# 使用dict()函数创建字典
myDict = dict(name='Alice', age=20, city='New York')

添加键值对：可以通过赋值运算符或update()方法向字典中添加键值对。例如：

# 使用赋值运算符添加键值对
myDict['gender'] = 'Female'

# 使用update()方法添加键值对
myDict.update({'phone': '1234567890', 'email': 'alice@example.com'})

删除键值对：可以使用del语句或pop()方法删除字典中的键值对。例如

# 使用del语句删除键值对
del myDict['phone']

# 使用pop()方法删除键值对
myDict.pop('email')

需要注意的是，如果删除不存在的键，会抛出KeyError异常。可以使用in关键字来检查键是否存在，或者使用get()方法来获取键对应的值。例如：

# 检查键是否存在
if 'name' in myDict:
    print('Name is present')
    
# 使用get()方法获取键对应的值
age = myDict.get('age')

字典的查询

使用方括号访问字典元素：可以使用字典的键作为索引，使用方括号来访问字典中的元素，例如：

# 创建一个字典
myDict = {'name': 'Alice', 'age': 20, 'city': 'New York'}

# 使用方括号访问字典元素
name = myDict['name']
age = myDict['age']
city = myDict['city']

使用items()方法遍历字典元素：可以使用items()方法来遍历字典中的所有键值对，例如：

# 遍历字典中的所有键值对
for key, value in myDict.items():
    print(key, value)

使用keys()方法和values()方法遍历字典键和值：可以使用keys()方法和values()方法分别遍历字典中的键和值，例如：

# 遍历字典中的所有键
for key in myDict.keys():
    print(key)

# 遍历字典中的所有值
for value in myDict.values():
    print(value)

字典元素的增删改

添加元素：可以使用方括号或者update()方法向字典中添加元素，例如：

# 使用方括号添加元素
myDict = {'name': 'Alice', 'age': 20, 'city': 'New York'}
myDict['gender'] = 'Female'

# 使用update()方法添加元素
myDict.update({'phone': '1234567890', 'email': 'alice@example.com'})

修改元素：可以使用方括号或者update()方法修改字典中的元素，例如：

# 使用方括号修改元素
myDict['age'] = 21

# 使用update()方法修改元素
myDict.update({'city': 'San Francisco', 'email': 'alice.new@example.com'})

删除元素：可以使用del语句或者pop()方法删除字典中的元素，例如：

# 使用del语句删除元素
del myDict['phone']

# 使用pop()方法删除元素
myDict.pop('email')

字典推导式

将列表中的元素作为字典中的键，将它们的索引作为对应的值：

myList = ['apple', 'banana', 'orange']
myDict = {value: index for index, value in enumerate(myList)}
print(myDict)  # {'apple': 0, 'banana': 1, 'orange': 2}

将字典中的键和值互换：

myDict = {'name': 'Alice', 'age': 20, 'city': 'New York'}
newDict = {value: key for key, value in myDict.items()}
print(newDict)  # {'Alice': 'name', 20: 'age', 'New York': 'city'}

根据条件筛选字典中的元素：

myDict = {'apple': 3, 'banana': 2, 'orange': 4, 'peach': 1}
newDict = {key: value for key, value in myDict.items() if value >= 3}
print(newDict)  # {'apple': 3, 'orange': 4}

集合

集合的创建以及删除

在Python中，可以使用花括号（{}）或者set()函数来创建一个集合。例如：

# 使用花括号创建集合
my_set = {1, 2, 3}

# 使用set()函数创建集合
my_set = set([1, 2, 3])

要删除集合中的元素，可以使用remove()或discard()函数。这两个函数都可以用来删除集合中的元素，但是当元素不存在时，remove()函数会抛出KeyError异常，而discard()函数不会。例如：

my_set = {1, 2, 3}

# 删除元素2
my_set.remove(2)

# 删除元素4（如果存在的话）
my_set.discard(4)

要删除整个集合，可以使用del关键字。例如：

my_set = {1, 2, 3}

# 删除整个集合
del my_set

集合的增删改

要向集合中添加元素，可以使用add()函数或者update()函数。add()函数用来添加一个元素，而update()函数可以用来添加多个元素。例如：

my_set = {1, 2, 3}

# 添加一个元素
my_set.add(4)

# 添加多个元素
my_set.update([5, 6, 7])

要从集合中删除元素，可以使用remove()函数、discard()函数或者pop()函数。remove()函数和discard()函数用来删除指定的元素，而pop()函数用来随机删除一个元素并返回该元素。例如：

my_set = {1, 2, 3}

# 删除指定的元素
my_set.remove(2)
my_set.discard(3)

# 随机删除一个元素
my_set.pop()

要更新集合中的元素，可以使用update()函数。update()函数可以用来添加新的元素，也可以用来修改已有的元素。例如：

my_set = {1, 2, 3}

# 添加新的元素
my_set.update([4, 5])

# 修改已有的元素
my_set.update([2, 3], [6, 7])

注意：集合中的元素是无序的，因此不能通过下标来访问集合中的元素，也不能直接修改集合中的元素。如果要修改集合中的元素，需要先将元素删除，然后再添加新的元素。

字符串

#字符串格式化
name = "Tom"
age = 18
s = "My name is %s and I am %d years old." % (name, age)
print(s)  # 输出结果为：My name is Tom and I am 18 years old.

name = "Tom"
age = 18
s = "My name is {} and I am {} years old.".format(name, age)
print(s)  # 输出结果为：My name is Tom and I am 18 years old.

#字符串分割
s = "apple,banana,orange"
lst = s.split(",")
print(lst)  # 输出结果为：['apple', 'banana', 'orange']

#字符串替换
s = "Hello World"
new_s = s.replace("World", "Python")
print(new_s)  # 输出结果为：Hello Python

#字符串大小写转换
s = "Hello World"
print(s.upper())  # 输出结果为：HELLO WORLD
print(s.lower())  # 输出结果为：hello world

#字符串去除空格
s = "  Hello World  "
print(s.strip())    # 输出结果为：Hello World
print(s.lstrip())   # 输出结果为：Hello World  
print(s.rstrip())   # 输出结果为：  Hello World

#字符串索引和切片
s = "Hello World"
print(s[0])    # 输出结果为：H
print(s[-1])   # 输出结果为：d
print(s[1:5])  # 输出结果为：ello

函数

input函数

  • 作用：接收来自用户的输入
  • 返回值类型：输入值的类型为str
  • 值得存储：使用=对输入得值进行存储

range函数

在这里插入图片描述

r = range(5) #[0,1,2,3,4]
print(r) #range(0,5)
print(list(r)) #[0,1,2,3,4]

r = range(1,5) #[1,2,3,4]
r = range(1,5) #[1,3]

自定义函数

函数的创建和调用

在这里插入图片描述

函数的返回值

  • 如果函数没有返回值，则return可以不写
  • 如果返回值是1个，直接返回原类型
  • 如果返回值有多个，返回的结果为元组

在这里插入图片描述
在这里插入图片描述

变量的作用域

全局作用域：在函数外部定义的变量拥有全局作用域，在整个程序中都可以被访问。

局部作用域：在函数内部定义的变量拥有局部作用域，只能在函数内部被访问。

在函数内部，可以使用 global 关键字声明一个变量为全局变量，这样这个变量就可以在函数外部被访问了。例如：

x = 10  # 全局变量

def func():
    global x  # 声明 x 为全局变量
    x = 5   # 修改全局变量 x 的值

func()
print(x)  # 输出 5

除了 global 关键字，Python 还有一个 nonlocal 关键字，用于在函数内部访问外层函数中的变量。例如：

def outer():
    x = 10  # 外层函数变量

    def inner():
        nonlocal x  # 声明 x 为外层函数变量
        x = 5   # 修改外层函数变量 x 的值

    inner()
    print(x)  # 输出 5

outer()

Bug及Pycharm调试

try except

try:
    # 代码块，可能会引发异常
except ExceptionType1:
    # 处理ExceptionType1异常
except ExceptionType2:
    # 处理ExceptionType2异常
else:
    # 如果try语句块没有引发异常，执行这里的代码
finally:
    # 不管try语句块是否引发异常，都会执行这里的代码

#示例
try:
    num = int(input("请输入一个整数："))
    result = 100 / num
    print(result)
except ValueError:
    print("输入的不是整数！")
except ZeroDivisionError:
    print("除数不能为0！")
finally:
    print("程序结束")

Traceback模块使用

traceback 模块提供了打印和处理 Python 解释器中发生的异常的功能

import traceback
try:
	print(1/0)
except:
	traceback.print_exc()

面向对象编程

类的定义和使用

class MyClass:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age

成员变量以及成员方法

成员变量是指属于类或对象的变量，可以在类的定义中或者在类的方法中使用。通常使用self关键字来表示类的实例对象。例如：

class MyClass:
    def __init__(self,y):
        self.x = y;

obj = MyClass(3)
print(obj.x)  # 输出 3
print(obj.y) # 'MyClass' object has no attribute 'y'

成员方法是类中定义的函数，它们用于执行特定的操作，并可以访问和修改类的成员变量。在类定义中，方法定义通常需要包含一个额外的参数self，以便在方法中访问成员变量和其他方法。例如：

class MyClass:
    def __init__(self, x):
        self.x = x
    
    def increment(self, y):
        self.x += y  # 访问成员变量
        return self.x
    
obj = MyClass(3)
print(obj.increment(2))  # 输出 5

构造方法

在 Python 中，构造方法是一个特殊的方法，它在实例化一个类的时候被调用。构造方法的名称是 init，它有一个必要参数 self，代表类的实例。
构造方法的作用是为新创建的实例对象初始化属性。例如，我们可以定义一个 Person 类，用于表示人类，构造方法可以用来初始化人的姓名和年龄等属性。

class Person:
    #name = None
    #age = None
    def __init__(self, name, age):
        self.name = name
        self.age = age

在这个例子中，Person 类有两个属性：name 和 age。构造方法使用 self.name 和 self.age 来初始化这两个属性。

当我们创建一个新的 Person 实例时，可以传入姓名和年龄的参数，这些参数会被传递到构造方法中：

person = Person("Alice", 25)

魔术方法

Python中的魔术方法（Magic Methods）是特殊的方法，它们以双下划线开头和结尾，例如__init__。这些方法在对象被创建、操作、销毁时自动调用，它们可以帮助我们实现自定义的行为和操作。

# __str__(self): 打印对象时自动调用的方法。
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def __str__(self):
        return f"Person(name={self.name}, age={self.age})"
        
person = Person("Alice", 25)
print(person)  # 输出：Person(name=Alice, age=25)

封装

在Python中，封装是一种面向对象编程的重要概念。它指的是将数据和方法包装在一起，以便控制对这些数据和方法的访问权限。

Python中的封装主要是通过使用访问控制符来实现的。访问控制符有两种：公有和私有。公有成员可以在类的任何地方访问，私有成员只能在类内部访问。
在Python中，用两个下划线开头的变量或方法名称表示私有成员，而没有下划线的变量或方法名称表示公有成员。

class Phone:
	__current_voltage = None
	def __keep_single_core(self):
		print("让CPU以单核模式运行") 
	
	def call_by_5g(self):
		if self.__current_voltage >= 1:
			print("5g通话已开启")
		else:
			print("无法使用")

继承

多继承

多个父类中，如果有同名的成员变量或者方法，那么默认以继承顺序（从左到右）为优先级，即：先继承的保留，后继承的被覆盖

#父类1
class Phone:
	IMET = None;
	producer = 'HM';
	
	def call_by_4g(self):
		print("4g通话");

#父类2
class NFCReader:
	nfc_type = "第五代";
	producer = "HM";

	def read_card(self):
		print("NFC读卡");
	
	def write_card(self):
		print("NFC写卡");

#父类3
class RemoteControl:
	rc_type = "红外遥控";
	
	def control(self):
		print("红外遥控开启了");


#子类
class MyPhone(Phone,NFCReader,RemoteControl):
	pass;

复写父类成员以及调用父类成员

#父类
class Phone:
	IMET = None;
	producer = 'HM';
	
	def call_by_4g(self):
		print("4g通话");

class MyPhone(Phone):
	producer = 'zHM';
	
	def call_by_4g(self):
		print('子类复用')
		super().call_by_4g(); #Phone.call_by_4g(self);

#子类重写父类的构造方法
class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed

类型注解

Python 中的类型注解是在变量、函数、方法等声明中，通过冒号加类型表达式的方式，指定变量或函数参数的类型和返回值类型。类型注解的作用是为代码添加类型信息，使得代码更易于理解、维护和调试。

Python 的类型注解并不会对代码的执行产生影响，即 Python 并不会强制检查类型注解的正确性，因此在程序运行时，变量或参数可以传入任意类型的值。类型注解只是提供了一种静态分析工具，可以帮助开发者在编码时检查类型错误。

变量的类型注解

#基础数据类型注解
var_1:int = 10;
var_2:str = 'gq';
var_3:bool = True;

#类对象注解
class Student:
	pass;
sut:Student = Student();

#基础容器类型注解
mu_list:list = [1,2,3];
my_tuple:tuple = (1,2,3);
my_dict:dict = {'gq':666};
#容器类型详细注解
mu_list:list[int] = [1,2,3];
my_tuple:tuple[int,str,int] = (1,'gq',3);
my_dict:dict[str,int] = {'gq':666};
#在注释中进行类型注解
a = 10; # type:int
my_dict = {'gq':666}; #type:dict
def func():
	return 10;
a = func(); #type:int

#类型注解的限制
类型注解只相当于一个备注，对于实际代码运行没有影响

函数（方法）的类型注解

def greet(name: str) -> str:
    return "Hello, " + name

Union类型

Python 中没有内置的 union 类型，但是在 Python 3.10 中引入了一个新的特性，叫做 “结构化类型”（Structural Types）或 PEP 604。其中就包括了 Union 类型，可以通过 typing 模块中的 Union 来实现。

Union 类型表示一个变量可以是多种类型中的一种，例如：

from typing import Union

def func(arg: Union[int, float, str]) -> None:
    print(arg)

多态

在 Python 中，多态是一种对象编程概念，指的是不同的对象可以使用同一种方法进行调用，而且这个方法会根据调用对象的不同而表现出不同的行为。

下面是一个示例，其中 Animal 是一个基类，Dog 和 Cat 是它的子类，它们都重写了 speak() 方法。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_speak(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

animal_speak(dog)  # 输出 "Woof!"
animal_speak(cat)  # 输出 "Meow!"

python操作mysql

基础使用

import pymysql

# 连接数据库
connection = pymysql.connect(
    host='localhost',
    user='username',
    password='password',
    database='database_name'
)

# 执行 SQL 语句
with connection.cursor() as cursor:
    sql = 'SELECT * FROM `table_name`'
    cursor.execute(sql)
    result = cursor.fetchall()
    print(result)

# 关闭数据库连接
connection.close()

在这个示例中，使用 pymysql.connect() 函数来连接到 MySQL 数据库。参数 host 是 MySQL 服务器的 IP 地址或主机名，user 和 password 是数据库用户的用户名和密码，database 是要连接的数据库的名称。

使用 with 语句和 cursor 对象来执行 SQL 查询语句。在这个示例中，查询所有的数据表记录并使用 cursor.fetchall() 获取所有结果。

最后使用 connection.close() 关闭数据库连接。

数据插入

import pymysql

# 连接数据库
connection = pymysql.connect(
    host='localhost',
    user='username',
    password='password',
    database='database_name'
)

# 插入数据
with connection.cursor() as cursor:
    sql = 'INSERT INTO `table_name` (`column1`, `column2`) VALUES (%s, %s)'
    values = ('value1', 'value2')
    cursor.execute(sql, values)
    connection.commit()

# 关闭数据库连接
connection.close()

在这个示例中，使用 cursor.execute() 方法和 sql 参数执行 SQL 语句，并使用 values 参数传递要插入的值。调用 connection.commit() 提交更改。最后，使用 connection.close() 关闭数据库连接。

还有许多其他的操作，如更新、删除、创建表等，都可以使用类似的方式来完成。

未完 待续。。。

我有点小叛逆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
python基础语法合集68页.pdf
05-08
《python基础语法合集68页.pdf》是一份详细介绍Python基础语法的资料，共计68页。本资料适用于初学者和有一定编程基础的人群，旨在帮助读者快速掌握Python基础语法知识，为进一步学习Python打下坚实的基础。 本资料...
python基础语法入门
最新发布
05-01
例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK...
python语法基础学习-Python语法学习一之基础语法
weixin_37988176的博客
10-30 69
注意Python是以缩进来代替其他编程语法中的 { }一、注释1-1、单行注释# 单行注释print('hello world')1-2、多行注释'''Python多行注释'''二、变量类型查看变量类型a = "cehae"print type(a)图片.png三、标识符3-1、标识符定义标示符由字母、下划线和数字组成，且数字不能开头，python中的标识符是区分大小写的。3-...
Python语法学习
花语无痕的博客
03-25 192
​Python 标识符 Python 中的标识符是区分大小写的。 以下划线开头的标识符是有特殊意义的。 以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。 以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。 Python 可以同一行显示多条语句，方法是用分号 ; 分开 Python ...
Python基础语法合集（极简）
qq_41946913的博客
04-26 671
在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。私有属性和私有变量只能在类里面访问和修改self.kongfu = '[古法煎饼果⼦配方]'print(f'运⽤{self.kongfu}制作煎饼果子')self.kongfu = '[⿊马煎饼果子配方]'print(f'运⽤{self.kongfu}制作煎饼果子')self.kongfu = '[独创煎饼果子配方]'#定义私有属性#定义私有方法。
python语法学习
da.的博客
10-27 537
1.初了解 1.1 print函数 #用print输出数字 print(520) print(98.5) #输出字符串 print('helloworld')#引号告诉计算机不需要你理解，你照着输出就可以了 #输出表达式 print(3+1) #将数据输出到文件中，注意1.所指定的盘符存在，2.使用file*fp fp=open('D:/text.txt','a+') #a+如果文件不存在就创建，存在就在文件内容的后面继续追加 print('helloworld',file=fp)#相当于print &gt
Python基础语法合集.pdf
06-06
Python基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdfPython基础语法合集.pdf
python基础语法
12-21
python语法基础 python靠缩进表达代码逻辑：缩进4个空格 注释：# （pycharm中：ctrl+?） 续行：\ 输入输出 输出：print() 输入：input() 标识符：变量、模块、函数、类等 首字符必须是字母或下划线 其他字符是字母...
Python基础语法题库（一）.docx
06-12
Python基础语法题库（一）全文共12页，当前为第1页。Python基础语法题库（一）全文共12页，当前为第1页。Python基础语法题库（一） Python基础语法题库（一）全文共12页，当前为第1页。 Python基础语法题库（一）...
Python基础语法合集
01-10
我自己整理的Python基础语法合集，变量，循环，输入输出等等都有，主要是知道概念和怎么用的 如果打开文件后有文字变成符号的，先把字体改为宋体就正常了
Python基础语法：.pdf
07-02
整理归纳Python基础语法，包括输入输出与变量定义，数据格式的拼接，常见基本数据类型索引、运算与操作，条件判断语句与循环语句
Python 基础语法
12-21
● / 永远返回一个浮点类型的数 ● 想要让除法最后返回一个整数类型的结果，可以使用 // 操作符 (只会去除小数点后的数字，不会进行四舍...● 除了整数(int)和浮点数(float)Python还支持其他数据类型如定点数(decimal)
Python基础语法.docx
02-28
在这篇文章中，我们将深入探讨Python语言，这是一种高级、解释型、...Python基础语法 变量和数据类型：Python是动态类型语言，不需要显式声明变量类型。支持的数据类型包括整型、浮点型、字符串、列表、元组、字典等
python基础语法知识点
03-12
python基础语法总结介绍，Python，if条件，循环，函数，⾯向对象，可变类型，字符串，引用，文件操作，异常处理，模块与包
python语法学习一
超人琪的博客
03-27 170
终于要学python啦，我的笔记是基于python3.6，看的课程是南京大学张莉老师的"用python玩转数据"。 首先呢，我是一名python小白，C语言基础一般般，学好python，将会是我人生中最值得骄傲的事情。 1.python执行方式 直接在shell中，短小的代码 新建py文件，较多的代码 2.语法 基本 1.标识符 1)首字母是字母或下划线 2)其余可以时字母、下划...
Python基本语法学习
Kindy
11-23 720
Python 基础知识
2020-10-30 从0学习ctf (2)
weixin_45871770的博客
10-30 146
Python3 基础语法 编码 默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码： # -*- coding: cp-1252 -*- 标识符 第一个字符必须是字母表中字母或下划线 _ 。 标识符的其他的部分由字母、数字和下划线组成。 标识符对大小写敏感。 在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。 python保留字 保留字即关键字，我们不能把它们用作任何标识符名称。Pyth

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值