python基础

最新推荐文章于 2025-06-12 22:38:01 发布

风间琉璃""

最新推荐文章于 2025-06-12 22:38:01 发布

阅读量1.3k

点赞数 36

文章标签： python 开发语言

本文链接：https://blog.youkuaiyun.com/2301_80217770/article/details/143664400

版权

python

声明：学习视频来自B站UP主泷羽sec,如涉及侵权马上删除文章。本文只涉及学习内容,其他的都与本人无关,切莫逾越法律红线,否则后果自负泷羽sec的个人空间-泷羽sec个人主页-哔哩哔哩视频微信公众号：泷羽sec

什么是python？

筒介

Python 是一个解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言更容易学习。

Python是一种解释型语言：这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言：这意味着，您可以在一个 Python提示待>>>后直接执行代码。

Python 是面向对象语言：这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python是初学者的语言：Python对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到www 浏览器再到游戏。

特点

1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
2.易于阅读：Python代码定义的更清晰。
3.易于维护：Python的成功在于它的源代码是相当容易维护的。
4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX,Windows和Macintosh兼容很好。
5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的浏试和调试代码片断。
6.可移植：基于其开放源代码的特性，Python已经被移植到许多平台。
7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.数据库：Python提供所有主要的商业数据库的接口。
9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入：你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化”的能力。

学会能干什么

脚本定制，爬虫，游戏开发（适合小游戏），web网站小程序（django,flask）,渗透测试攻击脚本（POC编写与利用），数据分析（pandas,numpy,Matplotlib,pyecharts等），机器学习（sklem,TensorFlow），写木马病毒等

pip的优势

自动解决依赖关系：pip在安装包时会自动解析和安装包的依赖项，避免了手动安装依赖的麻烦。
版本控制：pip可以轻松地管理不同版本的Python包，根据需要安装、更新或卸特定版本的包。
跨平台支持：pip可以在不同的操作系统和Python环境中使用，具有很好的跨平台支持能力。
社区支持：pip拥有庞大的用户群体和活跃的社区，这意味着在使用过程中遇到问题时可以快速找到解决方案或者得到社区的帮助。

pip 功能

查看pip版本

pip --version
&
pip -V

安装python包

pip install ……

卸载python包

pip uninstall ……

批量导出系统依赖

# 这个命令会讲当前环境中所有已安装的包及版本信息导出到requirements.txt文件中
pip  freeze > requirements.txt

批量安装库requirements.txt

pip install -r requirements.txt

列出所有已安装包

pip list

更新指定的包

pip install --upgrade package_name

指定下载源

pip install -i http://pypi.tuna.tsinghua.edu.cn/simple some-package

Pip基本数据类型

Python3中常见的数据类型有：

String（字符串）：制表符，换行符，切片，
bool（布尔类型）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
number （数字）

# num 数字型
num=10
print(type(num))#将会输出num这个字符是什么类型的
# <class 'int'>（输出结果）

# str 字符型
str="hello world"
print(type(str))
# <class'str'>

#list	列表
list=[1,2,3,4,5]
print(list)
#[1, 2, 3, 4, 5]
list[0]='hello'#修改列表中的第一个元素，第一个元素是0（像数组）
list[1]='world'
print(list)
# ['hello', 'world', 3, 4, 5]（经过修改后的输出）
print(type(list))
# <class 'list'>

#tuple 元族 不允许修改元素
tuple1=(1,2,3,4,5)
print(type(tuple1))
# <class 'tuple'>
print(tuple1)
# (1, 2, 3, 4, 5)

number (数字)

Python3 支持 int, float,bool,complex（复数）。

在python3里，只有一种整数类型int，表示为长整形，没有python2中的Long.

像大多数语言一样，数值类型的赋值和计算都是很直观的。内置的type()函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a),type(b),type(c),type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

String（字符串）

Python中的字符串常常用单引号''或者双引号""括起来，同时使用反斜杠**转意特殊字符。

字符穿的截取的语法格式如下：

变量[头下标：尾下标]

str = "this is a string"  #定义一个字符串变量

print(str)               # 打印整个字符串
print(str[0:-1])         # 打印字符串第一个到倒数第二个的字符（不包含倒数第一个字符）
print(str[0])            # 打印字符串第一个字符
print(str[2:5])          # 打印字符串第三个到第五个的字符（不包含第五个字符）
print(str[2:])           # 打印从第三个字符开始的字符串
print(str*2)             # 打印字符串两次
print(str+"world!")      # 打印字符串和"world!"连接

# 输出结果
this is a string         #整个字符串
this is a strin          # 字符串第一个到倒数第二个的字符
t                        # 字符串第一个字符
is                       # 字符串第三个到第五个的字符
is is a string           # 从第三个字符开始的字符串
this is a stringthis is a string # 字符串两次
this is a stringworld!   # 打印字符串和"world!"连接

python使用反斜杠转意特殊字符，如果不想让反斜杠发生转意，可以在字符串前面添加一个，表示原始字符串

print('hello\ni')
print('——分解线——')
print(r'hello\nihao')

输出结果：

hello
i     #这里的\n被当作啦python中的换行符，导致上面成了这个
——分解线——
hello\nihao

List（列表）

List（列表）是python中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构类型，列表中元素的类型可以不相同，支持数字，字符串甚至可以包含列表（所谓的嵌套）。列表写在[]（方括号）之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取语法格式如下：

变量[头下标：尾下标]

索引值以0开始，-1为从末尾的开始位置。加号+是列表连接运算符，星号*是重复操作。具体如下：

list = ['apple',786, 2.23, 'banana', 1.21]  #定义一个列表变量
onelist = [123, 'xyz']
print(list)               # 打印整个列表
print(list[0])            # 打印列表第一个元素
print(list[1:3])          # 打印列表第二个到第三个元素（不包含第三个元素）
print(list[2:])           # 打印从第三个元素开始的列表
print(list*2)             # 打印列表两次  
print(list+onelist)       # 打印列表和另一个列表连接

输出结果

['apple', 786, 2.23, 'banana', 1.21]  
apple                                 
[786, 2.23]
[2.23, 'banana', 1.21]
['apple', 786, 2.23, 'banana', 1.21, 'apple', 786, 2.23, 'banana', 1.21]
['apple', 786, 2.23, 'banana', 1.21, 123, 'xyz']

List 内置有很多方法，例如append()、pop()等等

列表推倒式

tuple = ('apple', 'banana', 'cherry')  #定义一个元组变量
list1 = [x for x in tuple]
list2 = [x for x in range(20)]    #range(20) 生成一个从 0 到 19 的整数序列（包括 0，不包括 20
print(list1)              # 打印整个元组
print(list2)

输出结果：

['apple', 'banana', 'cherry']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

append()和pop()的用法

append() 方法：

功能：在列表的末尾添加一个元素。
语法：list.append(element)
参数：element 是要添加到列表末尾的元素。
返回值：该方法没有返回值（返回 None），但它会就地修改列表。

pop() 方法：

功能：移除列表中的一个元素，通常是最后一个元素，但也可以指定索引来移除其他位置的元素。
语法：list.pop([index])
参数：index 是可选的，表示要移除的元素的索引。如果未提供索引，则默认移除并返回列表的最后一个元素。
返回值：该方法返回被移除的元素。

list = [1, 2, 3]  
list.append(4)  
print(list)  

print('——————————————————')
my_list = [1, 2, 3, 4]  
last_element = my_list.pop()  # 移除并返回最后一个元素  
print(last_element)  # 输出: 4  
print(my_list)  # 输出: [1, 2, 3]  

# 移除索引为1的元素  
removed_element = my_list.pop(1)  
print(removed_element)  # 输出: 2  
print(my_list)  # 输出: [1, 3]

输出结果：

[1, 2, 3, 4]
——————————————————
4
[1, 2, 3]
2
[1, 3]

Tuple （元组）

Tuple （元组）与list(列表)类似，不同之处在于元组的元素不能修改.元组卸载小括号()里面,元素之间用逗号,隔开。

元组推导式：

my_tuple = ('name', 2, 3)  # 更改变量名以避免与内置类型冲突  
x = (x for x in my_tuple)  # 生成器表达式  
  
# 打印生成器对象（显示的是内存地址）  
print(x)  # 例如：<generator object <genexpr> at 0x0000025...>  
print('——————————fenjie——————————')
# 打印生成器产生的值（转换为列表）  
print(list(x))  # 输出: ['name', 2, 3]  
print('——————————fenjie——————————')
  
# 或者，通过遍历来打印值  
x = (x for x in my_tuple)   # 如果要再次遍历，需要重新创建生成器表达式。
for value in x:  
    print(value)

输出结果：

<generator object <genexpr> at 0x10275d560>
——————————fenjie——————————
['name', 2, 3]
——————————fenjie——————————
name
2
3

Dictionary （字典）

字典dictionary是python中另一个非常有用的内置数据类型。列表是有序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典dictionary是一种映射类型，字典用花括号{}来标识，它是一个无序的键(key)：值（value）的集合。键（key）必须使用不可变类型。

在同一个字典中，键key必须是唯一的。

dict = {}
dict['one'] = "1 - 菜鸟"
dict[2]     = "2 - 菜鸟"

trydict = {
    'name': 'xtk',
    'code': 1, 
    'value': "菜鸟"}

print(dict['one'])       # 输出：1 - 菜��
print(dict[2])           # 输出：2 - 菜鸟
print(trydict)          # 输出：{'name': 'xtk', 'code': 1, 'value': '菜鸟'
print(trydict.keys())   # 输出所有的键
print(list(trydict.keys())) # 将所有的键转换为列表并输出
print(list(trydict.keys())[0])  #输出第一个键
print(trydict.values()) # 输出所有的值
print(list(trydict.values())) # 将所有的值转换为列表并输出

输出结果

1 - 菜鸟
2 - 菜鸟
{'name': 'xtk', 'code': 1, 'value': '菜鸟'}
dict_keys(['name', 'code', 'value'])
['name', 'code', 'value']
name
dict_values(['xtk', 1, '菜鸟'])
['xtk', 1, '菜鸟']

数字推倒式

num = 10
x={}  #初始化一个空字典

#使用enumerate函数遍历列表
for index, key in enumerate(['key1', 'key2', 'key3']):
    value = num * index    #计算对应的值
    x[key] = value          #添加键值对到字典
    
print(x)

输出结果：

{'key1': 0, 'key2': 10, 'key3': 20}

基础语法

条件控制

if和elif

str = input("你想成为黑客吗？（请输入Y或N）：")

if str == "Y":
    print("嗯你想想就好")
elif str == "N":
    print("那你就别想了")
else:
    print("你浑身都是反骨")

输出结果示例：

你想成为黑客吗？（请输入Y或N）：Y
嗯你想想就好

循环

while

i=10
o=0
while o<i:
    print(o)
    o+=1

输出结果：

Break的用法

i=10
o=0
while o<i:
    print(o)
    if o==5:
        break
    o+=1

输出主要就是跳出循环

0
1
2
3
4
5  #在o=5时跳出啦循环

Continue满足条件后跳过当前循环迭代中的剩余代码，并立即开始下一次迭代

i=10
o=0
while o<i:
    print(o)
    if o==5:
        continue
    o+=1

输出会在12345后不断重复5

#列表推倒式
list = [x for x in range(10)]
print(list)
#输出结果：
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for获取当前循环次数

list = []
for index,i in enumerate(range(1,11)):
     print(i)
    # print(index)  输出循环次数

pass 是一个空操作语句，它什么也不做。pass 语句通常用作占位符，以便在语法上需要一个语句但程序逻辑上不需要执行任何操作的地方。具体可以用来定义空函数或者类：

def my_function():
    pass  # 这里什么也不做，只是一个占位符

class MyClass:
    pass  # 定义一个空类

在条件语句或循环中占位:

if condition:
    pass  # 如果不需要执行任何操作，可以使用 pass

for item in iterable:
    pass  # 同样，如果需要循环但不执行任何操作，可以使用 pass

在异常处理中占位。

try:
    risky_operation()
except SomeSpecificException:
    pass  # 忽略这个异常，不执行任何操作

函数

调用函数：

#函数声明
def get_one():
    print('这是第一个函数')
    get_two()
    
def get_two():
    print('这是第二个函数')
    

    
if __name__ == '__main__':
    print('程序主入口')
    get_one()

输出结果：

程序主入口
这是第一个函数
这是第二个函数

参数传递：

def get_one(name,value):
    print(name)
    print(value)
    
if __name__ == '__main__':
    print('程序主入口')
    name='xtk'
    value='小菜鸟'
    get_one(name,value)

输出结果：

程序主入口
xtk
小菜鸟

迭代器

迭代是python最强大的功能之一，是访问集合元素的一种方式。可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不能往后。两个基本的方法：iter()和next()。

list = [1,2,3,4,5]
it = iter(list)
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))

输出结果：

迭代器对象写可以使用常规for语句进行遍历：

list = [1,2,3,4,5]
it = iter(list)
for x in it:
    print(x, end="")

输出结果：

12345%

list = [1, 2, 3, 4, 5]
it = iter(list)
try:
    print(next(it))  # 输出 1
    print(next(it))  # 输出 2
    print(next(it))  # 输出 3
    print(next(it))  # 输出 4
    print(next(it))  # 输出 5
    # 下一行尝试访问不存在的第六个元素，将引发 StopIteration 异常
    print(next(it))
except :
    print("迭代完成，没有更多元素")

输出结果：

1
2
3
4
5
迭代完成，没有更多元素

Except异常处理

while True:
    try:
        x = int(input("请输入一个数字："))
        break  # 如果输入成功转换为整数，则跳出循环
    except :  # 如果输入不能转换为整数，则捕获 ValueError 异常
        print("输入的不是数字，请重新输入！")  # 打印错误信息，并继续循环

输出结果：

输入一个数字：er
输入的不是数字，请重新输入！
请输入一个数字：

try-finally

Try-finally语句无论是否发生异常都将执行最后的代码。

try:
    runob()  # 这里假设runob是一个未定义的函数，将引发NameError
except NameError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)



finally:
    print("程序执行结束")  # 无论是否发生异常，这里都会输出

文件读写

# 读
file = "xx.txt"
a=open(file, mode='r')
print(a.read())

&# 不用手动关闭文件啦
file = "xx.txt"
with open(file, mode='r') as f:
print(f.read())

# 写
file = "xx.txt"
str='''
xxxxxxxx
'''
with open(file, mode='w') as f:
   f.write(str)