Python

最新推荐文章于 2024-07-10 19:27:42 发布

forget_1111

最新推荐文章于 2024-07-10 19:27:42 发布

阅读量935

点赞数 16

文章标签： python windows 开发语言

本文链接：https://blog.csdn.net/forget_1111/article/details/137384095

版权

Python 基础学习

1.前言

Python是一种解释型的、面向对象的、带有动态语义的高级程序设计语言。

优点：简单、易学、易读、易维护、用途广泛、速度较快、免费开源、可移植性、解释性、面向对象、可扩展性、可扩充性、可嵌入性、丰富的库、高级动态编程

2 语法简介

2.1 基本

注释： #，无c++多行注释

变量：无需声明，首次赋值才会创建变量,变量设置后还能改变类型

一行结束无需分号；

Python 使用缩进来指示代码块

x = 10
x = "hello"
# 注释
def print_hi(name):
    print(f'Hi, {name}')  # 缩进

2.1 内置数据类型

文本类型	str
数值类型	int,float,complex
序列类型	list,tuple,range
映射类型	dict
集合类型	set,forzenset
布尔类型	bool
二进制类型	bytes,bytearray,memoryview

获取数据类型

使用 type() 函数获取任何对象的数据类型
设置数据类型

变量赋值时，会设置数据类型

通过构造函数，指定数据类型如 x=str(“helloworld”)

Python 编程语言中有四种集合数据类型：

*列表（List）*是一种有序和可更改的集合。允许重复的成员。
*元组（Tuple）*是一种有序且不可更改的集合。允许重复的成员。
*集合（Set）*是一个无序和无索引的集合。没有重复的成员。
*词典（Dictionary）*是一个无序，可变和有索引的集合。没有重复的成员。

3 七大数据类型

3.1 数字类型

Python 中有三种数字类型 int float complex

x = complex(1, 3)
print(type(x))
y = 10
print(type(y))
# 结果
# <class 'complex'>
#<class 'int'>

3.2 字符串

python 中的字符串字面量由单引号或双引号括起。
可以使用三个引号将多行字符串赋值给变量

a = """Python is a widely used general-purpose, high level programming language. 
   """
    print(a)

字符串是数组

像许多其他流行的编程语言一样，Python 中的字符串是表示 unicode 字符的字节数组。但是，Python 没有字符数据类型，单个字符就是长度为 1 的字符串。方括号可用于访问字符串的元素。
裁切

可以使用裁切语法返回一定范围的字符。指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分。
负的索引

使用负索引从字符串末尾开始切片：
字符串长度

len() 函数

a = "Hello, World!"
print(a[1])     # e
print(a[2:4])   # ll  截断不含尾部，也就是尾部是开区间
print(a[-5:-1]) # orld
print(len(a))   # 13

字符串内置方法

strip() 方法删除开头和结尾的空白字符

lower() 返回小写的字符串

upper() 方法返回大写的字符串

replace() 用另一段字符串来替换字符串

split() 方法在找到分隔符的实例时将字符串拆分为子字符串

print(a.strip())
print(a.lower())
print(a.upper())
print(a.replace("World", "SB"))  # 如果在源字符串里面没找到，就不会进行替换
print(a.split(","))

# 结果打印
Hello, World!
       hello, world!
       HELLO, WORLD!
       Hello, SB!
['       Hello', ' World!']

检查字符串

检查字符串中是否存在特定短语或字符，我们可以使用 in 或 not in 关键字，结果返回是 True/False
字符串级联

串联或组合两个字符串，您可以使用 + 运算符，只允许两个字符串相加，而不能一个字符串加一个数值
字符串格式

可以使用 format() 方法组合字符串和数字！format() 方法接受传递的参数，格式化它们，并将它们放在占位符 {} 所在的字符串中

format() 方法接受不限数量的参数，并放在各自的占位符中

可以使用索引号 {0} 来确保参数被放在正确的占位符中

age = 63 
txt = "My name is {}, and my age is {}"
txt1 = "My name is {1}, and my age is {0}" # 索引顺序不一定按 {0} {1} 按序使用
print(txt.format("xiaoming", age))
print(txt.format(age, "xiaoming"))

所有字符串方法都返回新值。它们不会更改原始字符串。

方法	描述
capitalize()	把首字符转换为大写。
casefold()	把字符串转换为小写。
center()	返回居中的字符串。
count()	返回指定值在字符串中出现的次数。
encode()	返回字符串的编码版本。
endswith()	如果字符串以指定值结尾，则返回 true。
expandtabs()	设置字符串的 tab 尺寸。
find()	在字符串中搜索指定的值并返回它被找到的位置。
format()	格式化字符串中的指定值。
format_map()	格式化字符串中的指定值。
index()	在字符串中搜索指定的值并返回它被找到的位置。
isalnum()	如果字符串中的所有字符都是字母数字，则返回 True。
isalpha()	如果字符串中的所有字符都在字母表中，则返回 True。
isdecimal()	如果字符串中的所有字符都是小数，则返回 True。
isdigit()	如果字符串中的所有字符都是数字，则返回 True。
isidentifier()	如果字符串是标识符，则返回 True。
islower()	如果字符串中的所有字符都是小写，则返回 True。
isnumeric()	如果字符串中的所有字符都是数，则返回 True。
isprintable()	如果字符串中的所有字符都是可打印的，则返回 True。
isspace()	如果字符串中的所有字符都是空白字符，则返回 True。
istitle()	如果字符串遵循标题规则，则返回 True。
isupper()	如果字符串中的所有字符都是大写，则返回 True。
join()	把可迭代对象的元素连接到字符串的末尾。
ljust()	返回字符串的左对齐版本。
lower()	把字符串转换为小写。
lstrip()	返回字符串的左修剪版本。
maketrans()	返回在转换中使用的转换表。
partition()	返回元组，其中的字符串被分为三部分。
replace()	返回字符串，其中指定的值被替换为指定的值。
rfind()	在字符串中搜索指定的值，并返回它被找到的最后位置。
rindex()	在字符串中搜索指定的值，并返回它被找到的最后位置。
rjust()	返回字符串的右对齐版本。
rpartition()	返回元组，其中字符串分为三部分。
rsplit()	在指定的分隔符处拆分字符串，并返回列表。
rstrip()	返回字符串的右边修剪版本。
split()	在指定的分隔符处拆分字符串，并返回列表。
splitlines()	在换行符处拆分字符串并返回列表。
startswith()	如果以指定值开头的字符串，则返回 true。
strip()	返回字符串的剪裁版本。
swapcase()	切换大小写，小写成为大写，反之亦然。
title()	把每个单词的首字符转换为大写。
translate()	返回被转换的字符串。
upper()	把字符串转换为大写。
zfill()	在字符串的开头填充指定数量的 0 值。

3.3 布尔

True False

评估值和变量

bool() 函数可以评估任何值，并为您返回 True 或 False。

备注：大多数值都为 True

如果有某种内容，则几乎所有值都将评估为 True。

除空字符串外，任何字符串均为 True。

除 0 外，任何数字均为 True。

除空列表外，任何列表、元组、集合和字典均为 True。

实际上，除空值（例如 ()、[]、{}、“”、数字 0 和值 None）外，没有多少值会被评估为 False。当然，值 False 的计算结果为 False。
函数可返回布尔

Python 还有很多返回布尔值的内置函数，例如 isinstance() 函数，该函数可用于确定对象是否具有某种数据类型
```
print(isinstance(x, int))
print(bool("abc"))
print((10 > 5))
```

3.4 序列

3.4.1 列表

列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写。

使用 list() 构造函数创建列表，如：thislist = list((“apple”, “banana”, “cherry”)) # 请注意双括号

访问元素

通过引用索引号来访问列表项

负索引表示从末尾开始，-1 表示最后一个项目，-2 表示倒数第二个项目，依此类推。

可以通过指定范围的起点和终点来指定索引范围。注意：不包括终点的索引
更改元素

通过索引号更改特定的元素值
遍历列表

使用 for 循环遍历列表项： for x in list :
检查元素是否存在

in 关键字；如 a = x in list
列表长度 len(list) 方法
添加元素

追加： list.append(x)

指定索引处添加：list.insert(1, x)
删除元素

remove(元素) 方法删除特定的元素

pop() 方法删除指定的索引（如果未指定索引，则删除最后一项）

del 关键字删除指定的索引：del list[0]

del 关键字也能完整地删除列表：del list

clear() 方法清空列表
复制列表

您只能通过键入 list2 = list1 来复制列表，因为：list2 将只是对 list1 的引用，list1 中所做的更改也将自动在 list2 中进行。

有一些方法可以进行复制，一种方法是使用内置的 List 方法 copy()。

制作副本的另一种方法是使用内建的方法 list()
合并列表
- 通过+ 运算符
- list2 中的所有项一个接一个地追加到 list1 中
- 以使用 extend() 方法，其目的是将一个列表中的元素添加到另一列表中

演练：

thislist = ["apple", "banana", 1, 1, 3]
thislist[2] = "1"
for x in thislist:
    print(x)
    for x in thislist:
        print(x)
        print(thislist)
        print(len(thislist))
        thislist.append("orange")
        thislist.insert(1, "orange")
        del thislist[0]
        print(thislist[-1])
        print(thislist[1:3])
        thislist.remove("banana")

列表内建方法

方法	描述
append()	在列表的末尾添加一个元素
clear()	删除列表中的所有元素
copy()	返回列表的副本
count()	返回具有指定值的元素数量。
extend()	将列表元素（或任何可迭代的元素）添加到当前列表的末尾
index()	返回具有指定值的第一个元素的索引
insert()	在指定位置添加元素
pop()	删除指定位置的元素
remove()	删除具有指定值的项目
reverse()	颠倒列表的顺序
sort()	对列表进行排序

3.4.2 元组

元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。

和列表相同的操作
- 遍历
- 访问元组元素：索引，负索引
- 判断元素是否存在
- 元组长度
- 删除元组
- 合并元组：用 +
- tuple() 构造函数
通过重新构造元组的方式修改元组值

创建元组后，您将无法更改其值。元组是不可变的，或者也称为恒定的。但是有一种解决方法。您可以将元组转换为列表，更改列表，然后将列表转换回元组。
演练

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)
thistuple = tuple(("apple", "banana", "cherry"))  # 请注意双括号
print(thistuple)

元组内建方法

方法	描述
count()	返回元组中指定值出现的次数。
index()	在元组中搜索指定的值并返回它被找到的位置。

3.5 集合

集合是无序和无索引的集合。在 Python 中，集合用花括号编写。注意：每次执行，同一个set集合里面顺序是变化的，不像C++语言一样set是排序的。

和列表相同的操作
- 获取长度
- 遍历
- 清除集合
- 删除集合
- 使用 set() 构造函数来创建集合
添加元素

要将一个项添加到集合，使用 add() 方法。

要向集合中添加多个项目，使用 update() 方法。
删除元素

要删除集合中的项目，使用 remove() 或 discard() 方法。

两者区别：如果要删除的项目不存在，则 remove() 将引发错误而 discard() 不会引发错误。

可以使用 pop() 方法删除项目，但此方法将删除最后一项。请记住，set 是无序的，因此您不会知道被删除的是什么项目。pop() 方法的返回值是被删除的项目。
合并集合
- 使用 union() 方法返回包含两个集合中所有项目的新集合
- 使用 update() 方法将一个集合中的所有项目插入另一个集合中
- union() 和 update() 都将排除任何重复项。
  
  还有其他方法将两个集合连接起来，并且仅保留重复项，或者永远不保留重复项，请查看此页面底部的集合方法完整列表。
演练

thisset = {"apple", "banana", "orange"}
thisset1 = set(("apple", "banana", "cherry")) # 通过构造函数，请留意这个双括号
thisset.add("cherry")
thisset.update(["orange", "mango", "grapes"])
thisset.add("orange")
print(thisset)
set1 = {"a", "b", "c"}
set2 = {1, 2, 3}
set3 = set1.union(set2)
print(set3)

set 的内建方法

方法	描述
add()	向集合添加元素。
clear()	删除集合中的所有元素。
copy()	返回集合的副本。
difference()	返回包含两个或更多集合之间差异的集合。
difference_update()	删除此集合中也包含在另一个指定集合中的项目。
discard()	删除指定项目。
intersection()	返回为两个其他集合的交集的集合。
intersection_update()	删除此集合中不存在于其他指定集合中的项目。
isdisjoint()	返回两个集合是否有交集。
issubset()	返回另一个集合是否包含此集合。
issuperset()	返回此集合是否包含另一个集合。
pop()	从集合中删除一个元素。
remove()	删除指定元素。
symmetric_difference()	返回具有两组集合的对称差集的集合。
symmetric_difference_update()	插入此集合和另一个集合的对称差集。
union()	返回包含集合并集的集合。
update()	用此集合和其他集合的并集来更新集合。

3.6字典

字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。

相同操作
- 判断键是否存在 in
- 字典长度 len()
- clear() 关键字清空字典
- del 关键字也可以完全删除字典
- dict() 构造函数
访问项目

可以通过在方括号内引用其键名来访问字典的项目

可以通过 get() 的方法
更改值

通过引用其键名来更改特定项的值，和c++map类似
遍历字典

使用 for 循环遍历字典，循环遍历字典时，返回值是字典的键。

可以使用 values() 函数返回字典的值，及获取所有value值
添加项目

通过使用新的索引键并为其赋值，可以将项目添加到字典中
删除项目

pop() 方法删除具有指定键名的项

popitem() 方法删除最后插入的项目（在 3.7 之前的版本中，删除随机项目）

del 关键字删除具有指定键名的项目
复制字典

内建的字典方法 copy()

键入 dict2 = dict1 来复制字典，是引用的方式，修改一个另外一个也跟着修改

制作副本的另一种方法是使用内建方法 dict()，其实就是重新构造一个
嵌套字典

词典也可以包含许多词典，这被称为嵌套词典
演练

thisdict = dict(brand="Porsche", model="911", year=1963)
# 请注意，关键字不是字符串字面量, 使用了等号而不是冒号来赋值 与下面定义一样效果
# thisdict = {
#     "brand": "Porsche",
#     "model": "911",
#     "year": 1963
# }
print(thisdict)
print(thisdict)
for x in thisdict:
    print(x)
    print(thisdict[x])
    t1 = thisdict
    t1["year"] = 1965
    for x in thisdict.values():
        print(x)

内建方法。

方法	描述
clear()	删除字典中的所有元素
copy()	返回字典的副本
fromkeys()	返回拥有指定键和值的字典
get()	返回指定键的值
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
pop()	删除拥有指定键的元素
popitem()	删除最后插入的键值对
setdefault()	返回指定键的值。如果该键不存在，则插入具有指定值的键。
update()	使用指定的键值对字典进行更新
values()	返回字典中所有值的列表

4 控制语句

4.1 条件控制

#格式一
if 条件判断:
    执行块   #注意缩进

#格式二
if 条件判断:
    执行块
elif 条件判断：
	执行块

#格式三
if 条件判断:
    执行块
else
	执行块
#嵌套 If 可以在 if 语句中包含 if 语句，这称为嵌套 if 语句

简写方式

#如果只有一条语句要执行，则可以将其与 if 语句放在同一行
if a > b: print("a is greater than b")

#简写 if ... else
#如果只有两条语句要执行，一条用于 if，另一条用于 else，则可以将它们全部放在同一行
if a > b else print("B")

#同一行上使用多个 else 语句
if a > b else print("=") if a == b else print("B")

pass 语句

if 语句不能为空，但是如果您处于某种原因写了无内容的 if 语句，请使用 pass 语句来避免错误
```
if 4 > 2 :
    pass
```
逻辑运算符：与或非

与：and 或：or 非：not

4.2 循环

Python 有两个原始的循环命令：while 和 for

while 循环

#方式一：
while 条件语句:
	执行语句块
#方式二：
while 条件语句:
	执行语句块
else:
    代码块  #条件不成立后,只会运行一次

for 循环

for 循环用于迭代序列（即列表，元组，字典，集合或字符串）

这与其他编程语言中的 for 关键字不太相似，而是更像其他面向对象编程语言中的迭代器方法。

通过使用 for 循环，我们可以为列表、元组、集合中的每个项目等执行一组语句

注意：for 循环不需要预先设置索引变量
```
fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
```
range() 函数

如需循环一组代码指定的次数，我们可以使用 range() 函数，

range() 函数返回一个数字序列，默认情况下从 0 开始，并递增 1（默认地），并以指定的数字结束。

注意：range(10) 不是 0 到 10 的值，而是值 0 到 9。

range() 函数默认 0 为起始值，不过可以通过添加参数来指定起始值：range(3, 10)，这意味着值为 3 到 10（但不包括 10）

range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)

for 循环中的 else

for 循环中的 else 关键字指定循环结束时要执行的代码块
```
for x in range(10):
  print(x)
else:
  print("Finally finished!")
```
嵌套循环

嵌套循环是循环内的循环。“外循环”每迭代一次，“内循环”将执行一次

pass 语句

for 语句不能为空，但是如果您处于某种原因写了无内容的 for 语句，请使用 pass 语句来避免错误。
break 与 continue 和c++一样

5 函数

函数是一种仅在调用时运行的代码块。

创建函数

使用 def 关键字定义函数

参数在函数名后的括号内指定。您可以根据需要添加任意数量的参数，只需用逗号分隔即可。

可以有默认参数值

如函数需要返回值，可以使用 return 语句

关键字参数

可以使用 key = value 语法发送参数。参数的顺序无关紧要。

def my_function(child3, child2, child1):
  print("The youngest child is " + child3)
my_function(child1 = "Phoebe", child2 = "Jennifer", child3 = "Rory")

任意参数

在不知道将传递给您的函数多少个参数，可以在函数定义的参数名称前添加 *。

这样，函数将接收一个参数元组，并可以相应地访问各项。
```
def my_function(*kids):
  print("The youngest child is " + kids[2])
my_function("Phoebe", "Jennifer", "Rory")
```
递归
pass语句
lambda

lambda 函数是一种小的匿名函数。lambda 函数可接受任意数量的参数，但只能有一个表达式。

语法： lambda arguments : expression

lambda 函数可接受任意数量的参数

lambda 用作另一个函数内的匿名函数时，会更好地展现 lambda 的强大能力。

def tlambd(n):
    return lambda a: a * n

if __name__ == '__main__':

    x = lambda a: a + 10
    print(x(5))
    t = tlambd(2)
    print(t(4))

6 类

6.1 类和对象

Python 是一种面向对象的编程语言。Python 中的几乎所有东西都是对象，拥有属性和方法。对象 = 属性+方法。

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
**方法：**类中定义的函数。
**类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
**数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。
**方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
**局部变量：**定义在方法中的变量，只作用于当前实例的类。
**实例变量：**在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
**继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
**实例化：**创建一个类的实例，类的具体对象。
**对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

以上概念动高级语言的基本都差不多。

self 参数

self 参数是对类的当前实例的引用，用于访问属于该类的变量。它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数，当然也不一定为self名字，可以取其他名字，但意义一样。

**提示：**self 参数是对类的当前实例的引用，用于访问属于该类的变量。
删除对象属性与删除对象

可以使用 del 关键字删除对象的属性，如 del 对象名.属性 del 对象
私有变量和方法

变量名和方法名前面加两个下划线 __
构造函数 init() 函数

类都有一个名为 init() 的函数，属于内置函数，它始终在启动类时执行。使用 init() 函数将值赋给对象属性，或者在创建对象时需要执行的其他操作。
del 函数

属于类的内置函数，__del__用于当对象的引用计数为0时自动调用。__del__一般出现在两个地方：

1、手工使用del减少对象引用计数至0，被垃圾回收处理时调用。

2、程序结束时调用。__del__一般用于需要声明在对象被删除前需要处理的资源回收操作
其他内置函数见参考博客

(37条消息) Python 中类的内置方法（魔法函数）_python类的内置方法_ASDDAG的博客-CSDN博客
演练

class Person :
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def Print(self):
        # str1 = "name: " + self.__name + "  age : " + self.__age;
        print("name: " + self.__name)
        
# 创建对象
p = Person("xiaobai", 20)

6.2 继承和多态

继承允许我们定义继承另一个类的所有方法和属性的类。父类是继承的类，也称为基类。子类是从另一个类继承的类，也称为派生类。

**提示：**如果您在子类中添加一个与父类中的函数同名的方法，则将覆盖父方法的继承。

# 定义,其中 基类是 Person
class Student(Person):
    def __init__(self, name, age, sex)
    	super.__init__(name, age, sex)   # 调用父类的初始化函数

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

    def Print(self):
        # str1 = "name: " + self.__name + "  age : " + self.__age;
        print("name: " + self.__name)

class Student(Person) :
    def __init__(self, name, age):
        super().__init__(name, age)
        self.sex = "man"
    def Print(self):   # 重写父类方法
        print("name" + self.name + "  sex:" + self.sex)

7 模块

模块是包含一组函数的文件，希望在应用程序中引用。模块是包含一组函数的文件，希望在应用程序中引用。

使用模块

可以用 import 语句来导入模块，该语句会将模块内的所有内容导入。如：import moduleName

可以使用 from 关键字选择仅从模块导入部件。如： from moduleName import 具体部件

在使用 import 导入模块后，使用导入模块的函数、类等时，需要加上前缀模块名，如：moduleName.xxx

而from语句导入的部件使用时就不需要加上模块名

import mymodule
from mymodule1 import Person

mymodule.func()
P = Person(xxx)

8 总结

该文章简要描述了python的基本语法和数据类型，控制语句，函数，类和对象，继承和多态。对python语言的基础有个整体的认识。适用于有一定的高级语言编程基础的人学习。由于本人有一定的C++基础，所以对一些概念没去细究。对于不是python语言为主要开发的程序员来说，对python语言有一定的了解是非常有必要的，因为开发中少不了构建和脚本，自动化等，这些都是python语言擅长的哦~~,后续通过python实战同时对python语言的某些关键特性进行剖析来提升自己。。。敬请期待