python的基础学习

琪俊杰威。。

于 2023-05-26 18:17:16 发布

阅读量148

点赞数

文章标签：学习

本文链接：https://blog.csdn.net/qq_61275492/article/details/130850493

版权

1、注释

单行注释：以#开头，例子如下：

#第一个注释

print('Hello,python')#第二个注释

多行注释：使用'''或者" " ",例子如下：

'' 第三注释第四注释 '''

""" 第五注释第六注释 """

2、行与缩进

python的缩进数要含有相同的缩进空格，若缩进的空格数不一致，会导致运行错误:IndentationError: unindent does not match any outer indentation level

if True:
    print ("True")
else:
    print ("False")

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")    # 缩进不一致，会导致运行错误

3、多行语句

python在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \，没有在括号内的多行语句则需使用反斜杠\来换行。

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

#使用反斜杠/换行
total = item_one + \
        item_two + \
        item_three

4、数字类型

python中的数字类型有4种，整数（int）、布尔型（bool）、浮点数（float）、复数（complex)

int(整数）：如1

bool（布尔）：true

float(浮点数）：1.23、3E-2

complex(复数）：如1+2j

5、字符串（string）

(1)python使用引号来创建字符串（'、"）python单引号''和双引号" "的使用完全相同，只能指定一行字符

word = '字符串'
w = "双引号"

(2)使用三引号（''' 或者" " "）可以指定多行字符

paragraph = '''这是一个段落，
可以由多行组成'''
paragraph = """这是一个段落，
可以由多行组成"""

(3)使用反斜杠\n转义特殊字符，\n不打印

print('hello\nrunboob)
#打印时，\n不打印，换行显示

hello
runoob

(4)在字符串前面添加r，不会发生转义，会显示\n

print(r'hello\nrunoob')

#输出结果为：
hello\nrunoob

(5)Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始,字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

str = '123456789'

print(str) #输出字符串
print(str[0:-1]) #输出第一个字符串到倒数第二个字符串
print(str[0])  #输出字符串第一个字符
print(str[2:5]) #输出从第三个开始到第五个的字符
print(str[2:]) #输出从第三个开始后的所有字符
print(str[1:5:2]) #输出从第二个开始到第五个且每隔一个字符就相当于已走过两个字符
print(str*2) #输出字符串两次
print(str + '你好'） #连接字符串

输出结果如下：
123456789
12345678
1
345
3456789
24
123456789123456789
123456789你好

var1 = 'Hello World！'
var2= "Runoob"
print("var1[0]:",var1[0])
print("var2[1:5]:",var2[1:5])

输出结果为：
var1[0]: H
var2[1:5]:unoob

#截取字符串的一部分并与其他字段拼接
var1 = 'Hello World!'
print("已更新字符串：",var1[:6] + 'Runood!'

输入结果为：
已更新字符串： Hello Runoob!

(6)Python字符串运算符

+:字符串连接

*:重复输出字符串

[]:通过索引获取字符串中字符

[:]:截取字符串中的一部分，遵循左闭右开原则

in:成员运算符-如果字符串中包含给定的字符返回True

not in ：成员运算符-如果字符串中不包含给定的字符返回True

a="Hello"
b="Python"
print("a+b输出结果:"，a+b) #a+b输出结果： Hello Python
print("a*2输出结果:",a*2) #a*2输出结果：HelloHello
print("a[1]输出结果：",a[1]) #a[1]输出结果：e
print("a[1:4]输出结果:",a[1:4]) #a[1:4]输出结果：ell

if("H" in a):
    print("H在变量a中")
else:
    print("H不在变量a中")
#H在变量a中

if("M" not in a):
    print("M不在变量a中"）
else:
    print("M在变量a中")
#M不在变量a中

（7）格式化字符串：f-string 是python3.6之后版本添加的，称之为字面量格式化字符串，格式化字符串时以f开头，后面跟着字符串，字符串的表达式用{}包起来，会将变量或表达式计算后的值替换进去。

name = 'Runoob'
f'Hello{name}' #替换变量，输出结果：'Hello Runoob'
f{'1+2'} #使用表达式:'3'

6、print输出

print默认输出是换行的，若想输出的结果不换行则需要在变量末尾加上end = " "

x = 'a'
y = 'b'

#换行输出
print(x)
print(y)
 

#不换行输出
print(x,end = " ")
print(y,end = " ")

执行结果：
a
b

a b

7、import 与 from...import

在Python中用import 或者from...import来导入相应的模块

将整个模块（somemodle）导入：import somemodle

从某个模块中导入某个函数，格式为：from somemodle import somefunction

从某个模块中导入多个函数,格式为：from somemodle import firstfunc,secondfunc

将某个模块中的全部函数导入，格式为：from somemodle import *

8、python的基本数据类型

（1）变量：python中的变量不需要声明，但是每个变量在使用前都必须赋值

使用等号（=）来给变量赋值，等号（=）左边是一个变量名，右边是存储在变量中的值。

counter = 100 #整型变量
miles = 1000.0 #浮点型变量
name = "runoob" #字符串

print(counter)
print(miles)
print(name)

输出结果：
100
1000.0
runoob

(2)允许多个变量赋值

a = b = c = 1
#a、b、c三个变量均被赋值为1

a, b, c = 1, 2, "runoob"
#a被赋值为1，b被赋值为2，c被赋值为字符串runoob

（3）python常见的标准数据类型有六个：

不可变数据（3个）：Number(数字)、String（字符串）、Tuple（元组）

可变数据（3个）：List（列表）、Dictionary（字典）、Set（集合）

此外，还有一些高级的数据类型，如：字节数组类型（bytes）

（4）python数字类型转换：

int(x)将x转换成一个整数

float(x）将x转换到一个浮点数

complex(x)将x转换到一个复数。实数部分为x，虚数部分为0

complex(x,y)将x和y转换到一个复数，实数部分为x，虚数部分为y

#将浮点数变量a转换为整数
a = 1.0 
int(a)
1

2+2
4  #加法

50-5*6
20  #先算乘法再算减法

8/5 
1.6  #总是返回一个浮点数

17//3 
5  #整数除法返回向下取整后的值

7.0 // 2
3.0 

7//2.0
3/0  # //得到的并不一定是整数类型，与分子分母的数据类型有关

5 **2 #5的平方
2 ** 7 #2的7次方  #使用**来操作幂运算

9、列表

列表都可以进行的操作包括索引，切片，加，乘，检查成员；可以作为一个方括号内的逗号分隔值出现。

#创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
list1 = ['Google','Runoob',1997,2000]

#与字符串的索引一样，列表索引从0开始，第二个索引是1，以此类推
list = ['red','green','blue','yellow','white','black']
print(list[0])
print(list[1])
print(list[2])
#输出结果：red、green、blue

#从第二位开始（包含）截取到倒数第二位（不包含）
print("list[1:-2]:",list[1:-2])
#输出结果：
list[1:-2]:['green','blue','yellow']

nums = [10,20,30,40,50,60,70,80]
print(nums[0:4])
#输出结果：[10,20,30,40]

#对列表的数据项进行修改或更新，可使用append（）方法添加列表项
list = ['Google', 'Runoob', 1997, 2000]

print("第三个元素为：",list[2])
list[2]=2001
print("更新后的第三个元素为：",list[2])  #更新后的第三个元素为：2001

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('baidu')
print("更新后的列表：",list1) #更新后的列表： ['Google', 'Runoob', 'Taobao', 'Baidu']

#使用del语句来删除列表的元素
list = ['Google', 'Runoob', 1997, 2000]
print("原始列表：",list)
del list[2]
print("删除第三个元素：",list) #删除第三个元素：['Google', 'Runoob', 2000]

10、元组

python的元组与列表类似，不同之处在于元组的元素不能修改，元组使用小括号(),列表使用方括号[]，元组的创建很简单，只需在括号中添加元素，并使用逗号隔开即可。

#创建空元组
tup1 = ()

#元组中只包含一个元素时，需要在元素后面添加逗号,否则括号会被当作运算符使用
tup1 = (50) #不加逗号，类型为整数

tup2 = (50,) #添加逗号，类型为元组

元组与字符串类似，下标索引从0开始，可以进行截取、组合等。
tup1 = ('gooole','runob',1997,3000)
tup2 = (1,2,3,4,5,6,7,8)

print("tup1[0]:",tup1p[0]) #tup1[0]:gooole
print("tup2[1:5]:",tup2[1:5]) #tup2[1:5]:(2,3,4,5)

#元组中的元素值是不允许修改的，但可以对元组进行连接组合，如下实例：
tup1 = (12,34.56)
tup2 = ('abc','xyz')

#创建一个新的元组
tup3 =tup1+tup2
print(tup3)  #输出结果：(12, 34.56, 'abc', 'xyz')

#元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组，如下实例：
tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

11、字典

字典是另一种可变容器模型，且可存储任意类型对象，字典的每个键值对使用冒号:分割，每个对之间用，分割，整个字典包括在花括号中{},格式如下所示：

d= {key1:value1,key2:value2,key3:value3}

字典的键key必须是唯一的，但值value则不必；值可以取任何数据类型，但键则是不可变的，可用数字、字符串或元组充当，用列表则不行

#创建空字典
emptyDict = {}

#创建字典
tinydict1 = {'abc':123}
tinydict2 = {'abc':123,98.6:37}

#打印字典
print(tinydict1)

#查看字段的数量
print("length:",len(tinydict1))

#查看类型
print(type(tinydict1))

#访问字典里的值
tinydict = {'name':'runoob','age':7,'class':'first'}
print("tinydict['name']:",tinydict['name'])
print("tinydict['age']:",tinydict['age'])

#输出结果为：
tinydict['name']:runoob
tinydict['age']:7

#修改字典：向字典添加新内容的方法是增加新的键/值对，修改或删除已有建/值对如下实例。
tinydict = {'name':'runoob','age':7,'class':'first'}
tinydict['age'] = 8 #更新age
tinydict['school'] = "菜鸟教程"
print(tinydict['age'])  #输出：8
print(tinydict['school']) #输出：菜鸟教程



#删除字段元素，能删单一的元素也能清空字典，清空只需一项操作，显式删除一个字典用del命令
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

12、集合

集合（set）是一个无序的不重复元素序列，可使用大括号{}或者set()函数来创建集合

注意：创建一个空集合必须使用set(),因为{}是用来创建一个空字典

#创建集合的格式：
parame = {value1,value2,value3}
或者
set(value)

#集合是一个无序的不重复元素序列
basket = {'apple','orange','apple','orange',''banana}
print(basket）

#输出：{'orange', 'banana', 'pear', 'apple'} --演示的是去重功能

'orange' in basket --快速判断元素是否在集合内

a = set('abracadabra')
b = set('alacazam')
a-b  #集合a中包含而集合b中不包含的元素
a|b  #集合a或b中包含的所有元素
a&b  #集合a和b中都包含了的元素
a^b  #不同时包含于a和b的元素

 s.add(x) #将元素x添加到集合s中，若元素已存在，则不进行任何操作
thisset = set(("google","runoob","taobao"))
thisset.add("facebook")
print(thisset)
{'taobao','facebook','google','runoob'}
 
s.update(x)  #可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

s.remove(x)  #将元素x从集合s中移除，如果元素不存在，则会发生错误
thisset = set(("google","runoob","taobao"))
thisset.remove("taobao")

13、条件控制

python中的if语句的一般形式如下所示：

if condition_1: statement_block_1

elif condition_2: statement_block_2

else: statement_block_3

如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为False，将执行"statement_block_3"块语句

#例子：对狗的年龄计算判断-
age = int(input("请输入你家狗狗的年龄："))
print("")
if age <= 0:
    print("你是在逗我吧！")
elif age == 1:
    print("相当于14岁的人")
elif age == 2:
    print("相当于22岁的人")
elif age >2:
    human = 22 + (age -2)*5
    print("对应人类年龄：",human)
input("点击enter键退出")

执行结果：
请输入你家狗狗的年龄: 1

相当于 14 岁的人。
点击 enter 键退出

#if嵌套

num = int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print("你输入的数字可以整除2和3")
    elif:
        print("你输入的数字可以整除2，但不能整除3")
elif:
    if num%3==0:
        print("你输入的数字可以整除3，但不能整除2")
     else:
        print("你输入的数字不能整除2和3")
执行结果：
输入一个数字：6
你输入的数字可以整除 2 和 3


match ... case
match后的对象会依次与case后的内容进行匹配，若匹配成功，则执行匹配到的表达式，否则直接跳过，_可以匹配到一切
例子:
def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "a teapot"
        case _:
            return "something wrong with the internet"
mystatus=400
print(http_error(400))

一个 case 也可以设置多个匹配条件，条件使用 ｜ 隔开，例如：case 401|403|404:

14、while循环

while 判断条件(condition)：
    执行语句(statements）

break语句可以跳出for和while的循环体。若从for或while循环中终止，任何对应的循环else块将不执行。

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

#while中使用break

n = 5 
while n > 0:
    n -=1
    if n == 2:
        break
    print(n)
print('循环结束')

输出结果：
4
3
循环结束

#while中使用continue

n = 5
while n>0:
    n -=1
    if n == 2:
        continue
    print(n)
print('循环结束')

输出结果为：
4
3
1
0
循环结束

更多实例：
for letter in 'Runoob':   #第一个实例
    if letter == 'b':
        break
    print('当前字母为：',letter)
输出结果为：
当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o

var = 10  #第二个实例
while var > 0:
    print('当前变量值为：',var)
    var = var -1
    if var == 5:   #变量为5时跳过输出
        break
print("good bye!")
输出结果为：
当前变量值为 : 10
当前变量值为 : 9
当前变量值为 : 8
当前变量值为 : 7
当前变量值为 : 6
Good bye!


#循环语句中可以有else子句，在穷尽列表（以for循环）或条件变为false（以while循环）导致循环终止时被执行，但循环被break终止时不执行。

for n in range(2:10):
    for x in range(2,n):
        if n%x == 0:
            print(n,'等于',x,'*',n//x)
            break
    else:
        print(n,'是质数')

执行以上脚本输出结果为：
2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

15、编程第一步实例

#打印字符串
print("Hello,world")
输出结果为：
Hello,world!

#输出变量值
i = 256*256
print('i的值为：',i)
输出结果为：
i的值为：65536

#定义变量并进行简单的数学运算
x = 3
y = 2
z = x+y
print(z)
输出结果为：
5

#定义一个列表并打印出其中的元素
my_list = ['google','runoob','taobao']
Print(my_list[0]) #输出"google"
print(my_list[1]) #输出"runoob"
print(my_list[2]) #输出"taobao"
输出结果为：
google
runoob
taobao

#使用fro循环打印数字0到4
for x in range(5)
    print(x)
输出结果为：
0
1
2
3
4

#根据条件输出不同的结果
x = 6
if x >10:
    print("x大于10")
else:
    print("x小于或等于10")
输出结果为：
x小于或等于10

#关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符
a,b = 0,1
while b < 1000:
    print(b,end=',')
    a,b = b,a+b
输出结果为：
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

16、推导式

（1）列表推导式格式：

[表达式 for 变量 in 列表]

[表达式 for 变量 in 列表 if 条件]

列表推导式：

#过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper()from name in names if len(name)>3]
print(new_names)
输出结果为：
['ALICE','JERRY','WENDY','SMITH']

#计算30以内可以被3整除的整数
multiples = [i for i in range(30) if i%3 == 0]
print(multiples)

（2）字典推导式格式：

{key_expr: value_expr for value in collection}

或

{key_expr:value_expr for value in collection if condition}

#使用字符串及其长度创建字典：
listdemo = ['google','runoob','taobao']
#将列表中各字符串值为键，各字符串的长度为值，组成键值对
newdict = {key:len(key) for key in listdemo}
newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

#提供3个数字，以3个数字为键，3个数字的平方为值来创建字典：
dic = {x:x**2 for x in (2,4,6)}
dic
{2:4,4:16,6:36}
type(dict)
<class 'dict'>

（3）集合推导式格式：

{expression for item in Sequence}

{expression for item in Sequence if conditional}

#计算数字1,2,3的平方数

setnew = {i**2 for i in (1,2,3)}

setnew
{1,4,9}

#判断不是abc的字母输出
a = {x for x in 'abracadabra'} if x not in 'abc'}
a
{'a','r'}

(3)元组推导式

元组推导式可以利用range区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。基本格式为：

(expression for item in sequence)

或

（expression for item in sequence if conditional）

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用()圆括号将各部分括起来，而列推导式用的是中括号[]，另外元组推导式返回的结果是一个生成器对象

#例如，可以使用下面的代码生成一个包含数字1~9的元组：
a = (x for in range(1,10))
a
<generator object <genexpr> at ox7faf6ee20a50> #返回的是生成器对象
tuple(a) #使用tuple（）函数，可以直接将生成器对象转换成元组
（1,2,3,4,5,6,7,8,9）

17、迭代器与生成器

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

字符串、列表或元组对象都可用于创建迭代器。

list = [1,2,3,4]
it = iter(list) #创建迭代器对象
print(next(it)) #输出迭代器的下一个元素
1
print(next(it))
2

#迭代器对象可以使用常规for语句进行遍历:
list = [1,2,3,4]
it = iter(list) #创建迭代器对象
for x in it:
    print(x,end="") #end=""不换行
1,2,3,4

#使用next()函数
import sys #引入sys模块
list = [1,2,3,4]
it = iter(list) #创建迭代器对象
while True:
    try:
        print(next(it))
    except StopIteration:
    sys.exit()
执行以上程序，输出结果如下：
1
2
3
4

18、函数

定义函数的简单规则：

函数代码块以def关键词开头，后接函数标识符名称和圆括号().

任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串-用于存放函数说明

函数内容以冒号:起始，并且缩进。

return[表达式]结束函数，选择性地返回一个值给调用方，不带表达式的return相当于返回None。

python定义函数使用def关键字，一般格式如下：

def 函数名（参数列表）:

函数体

#使用函数输出"Hello world!"
del hello():
    print("Hello world!")
hello()

更复杂点的应用，函数中带上参数变量：
#比较两个数，并返回较大的数：

def max(a,b):
    if a > b:
        return a
    else:
        return b
a = 4
b = 5
print(max(a,b))
执行结果为：
5

#计算面积函数
def area(width,height):
    return width * height

def print_welcome(name):
    print("welcome",name)

print_welcome("Runoob")
w = 4
h = 5
print("width=",w,"height=",h,"area=",area(w,h))
执行结果为：
welcome Runoob
width = 4 height = 5 area = 20

#调用printme()函数
#定义函数
def printme(str):
    print(str)  #打印任何转入的字符串
    return
#调用函数
printme("我要调用用户自定义函数！")
printme("我要调用同一函数")
执行结果为：
我要调用用户自定义函数！
我要调用同一函数