【Python】基础内容

简介

  • 面向对象,解释型的编程语言
  • 使用缩进作为逻辑层次

运行效率较低
【Python】基础内容_第1张图片


  • 单行注释:以#开头:#注释内容
  • 多行注释:以一对三个双引号引起来的内容: “”“注释内容”“”

数据类型

type(被查看类型的数据):查看数据类型

数字(Number)

整数(int)
Python可以处理任意大小的整数

  • 二进制整数使用前缀0b表示,例如:0b110,0b1100
  • 十六进制整数使用前缀0x表示,例如:0x12ef,0xde2431af

浮点数(float)
浮点数可以用正常写法:1.23,3.14,-9.01
也可以使用科学计数法表示:1.23e9(1.23*10^9)
注意:浮点数的运算可能会有误差
在这里插入图片描述

复数(complex)
以j结尾表示复数,如4+3j

布尔值(bool)
布尔值只有True,False两种值,可以使用and,or,not进行运算
True本质上是一个数字记作1,False记作0

字符串(String)

描述文本的一种数据类型

字符串可以用’'或""括起来表示
如果字符串本身包含单引号,这时可以用双引号括起来表示,如果包含双引号,就可以用单引号括起来表示,如果字符串既包含单引号也包括双引号,那么需要使用\进行转义。

常用的转义字符还有:
\n表示换行
\t 表示一个制表符
\\表示 \ 字符本身

raw字符串
如果一个字符串包含很多需要转义的字符,对每一个字符都进行转义会很麻烦,我们可以在字符串前面加个r,表示这是一个raw字符串,里面的字符就不需要转义了。

print(r"c:\newfile\test.py")
#c:\newfile\test.py
print("c:\newfile\test.py")
#c:
#ewfile	est.py

raw'...',不能表示多行字符串,也不能表示包含’和"的字符串(不能转义)

多行字符串
使用'''...'''表示多行字符串

print('''Line 1
Line 2
Line 3''')

也可以在多行字符串前面添加r,把这个多行字符串也变成raw字符串

字符串切片

前闭后开区间

s = 'ABCDEFG'
s1 = s[0:2]
print(s1)   # AB
s2 = s[2:4]
print(s2)   # CD

以’'或""括起来的任意文本


字符串拼接

通过+可以将两个字符串拼接在一起

name = "world"
print("hello" + name) # helloworld

字符串格式化
%占位
% 表示:我要占位
s 表示:将变量变成字符串放入占位的地方
综合起来:我先占个位置,等一会有个变量过来,我把它变成字符串放到占位的位置
(%d:将内容转换成整数,放入占位位置;%f:将内容转换成浮点数,放入占位位置)

name = "David"
tel = 1234567
message = "姓名:%s,电话:%d" % (name, tel)
print(message) # 姓名:David,电话:1234567
print("%f" % tel) # 1234567.000000

精度控制
可以使用符号m.n来控制数据的宽度和精度
m控制宽度,要求是数字,设置的宽度小于数字自身,不生效
.n控制小数点精度,要求是数字,会进行小数的四舍五入

print("%5d" % 11) # [空格][空格][空格]11,用三个空格补齐宽度
print("%7.2f" % 11.345) # [空格][空格]11.35,小数部分限制两位四舍五入为.35,用两个空格补齐宽度
print("%.2f" % 11.345) # 11.35,不限制宽度,只设置小数点精度为2

f"内容{变量}"

  • 不理会类型
  • 不做精度控制
name = "David"
sex = "male"
age = 20
print(f"我是{name},我的性别是{sex},我的年龄是{age}")

format

print('{} {}'.format("hello", "world"))     # hello world
print('{0} {1}'.format("hello", "world"))   # hello world
print('{1} {0}'.format("hello", "world"))   # world hello
print("hello:{country}, hello:{city}".format(country="china", city="beijing"))  # hello:china, hello:beijing
a = 3
b = 4
print('{} + {} = {}'.format(a, b, a+b))     # 3 + 4 = 7

列表(List)

有序的可变序列

元组(Tuple)

有序的不可变序列

集合(Set)

无序不重复集合

字典(Dictionary)

无序Key-Value集合

空值(None)

空值
空值用None表示

  • 函数无返回值
  • if判断:None等同于False
  • 声明无内容变量

数据类型转换

  • int(x):将x转换为一个整数
  • float(x):将x转换为一个浮点数
  • str(x):将对象x转换为字符串

浮点数转换为整数会丢掉小数部分,字符串必须为纯数字才能转换为数字

标识符的命名规则

  • 大小写敏感
  • 标识符由大小写英文字母、数字、中文和下划线组成(不推荐使用中文)
  • 标识符不能由数字开头
  • 标识符不能与Python关键字重合(比如:and、or、not)

标识符命名规范

  • 英文字母全小写
  • 多个单词之间用下划线分隔

定义变量

变量没有类型,字符串变量表示变量存储了字符串而不是表示变量就是字符串

变量名 = 数据

一个变量可以先后存储多种不同类型的数据

a = 1 # 这个时候a存储的是整数类型
print(a)
a = 'ABC' # 这个时候a存储的是字符串类型
print(a)

运算符

算数运算符

加减乘除

整数与浮点数运算的结果是浮点数
除法的运算结果是浮点数

# 加法
num1 = 10
num2 = 0.5
result = num1 + num2
print(result) # ==> 10.5
# 减法
result = num1 - num2
print(result) # ==> 9.5
# 乘法
result = num1 * num2
print(result) # ==> 5.0
# 除法
result = num1 / num2
print(result) # ==>20.0

取模

print(3 % 2) # ==> 1
print(33 % 10) # ==> 3
print(99 % 30) # ==> 9

地板除

与普通除法相比,会忽略结果的纯小数部分,使用//进行
都为整型则结果也为整型,只要有一个float,则返回float

print(10//4) # ==> 2
print(10//2.5) # ==> 4.0
print(10//3) # ==> 3

保留小数点位数
round(),第一个参数是需要保留小数点位数的数值,第二个参数是保留的位数

print(round(3.344, 2)) # ==> 3.34
print(round(3.345, 2)) # ==> 3.35

指数

a**b:为a的b次方

print(5**2) # ==> 25

赋值运算符

  • =:赋值运算符,把 = 右边的结果赋给左边的变量
  • +=:c+=a等效于c=c+a
  • -=
  • *=
  • /=
  • %=
  • **=
  • //=

输入输出

数据输出:print()

  • print默认换行输出,在print后加上end=‘’,即可实现输出不换行print("hello", end="")

数据输入:input()

  • 使用input()语句可以从键盘获取输入
  • 使用一个变量接受input语句获取的键盘输入数据即可
  • 在input()的括号中输入语句,会在输入前输出这段提示语句
  • 输入的数据都看作是字符串

判断语句

布尔类型

与运算
两个布尔值都为True时,结果为True

True and True # ==> True
True and False # ==> False
False and True # ==> False
False and False # ==> False

或运算
只要有一个值为True,结果就为True

True or True # ==> True
True or False # ==> True
False or True # ==> True
False or False # ==> False

非运算
True变为False,False变为True

not True # ==> False
not False # ==> True

布尔类型也可以与其他类型做运算
Python把0、空字符串和None看成False,其他数值和非空字符串都看成True

print(True and 0 or 99) # ==> 99

要解释以上结果需要涉及到短路计算

  1. 在计算a and b时,如果 a 是 False,则根据与运算法则,整个结果必定为 False,因此返回 a;如果 a 是 True,则整个计算结果必定取决与 b,因此返回 b。
  2. 在计算a or b时,如果 a 是 True,则根据或运算法则,整个计算结果必定为 True,因此返回 a;如果 a 是 False,则整个计算结果必定取决于 b,因此返回 b

True and 0 or 99:首先计算True and 0,根据短路计算返回0,然后计算0 or 99,根据短路计算返回99

比较运算符
==、!=、>、<、>=、<=

if-else

  • 通过缩进表示这行代码是if/else判断的一个子分支(表示这行代码属于哪个语句)
  • 在if/else后有一个:,表示接下来是分支代码块
score = 59
if score < 60:
    print('抱歉,考试不及格')
else:
    print('恭喜你,考试及格')

elif 相当于 else if , 可以简化逻辑

score = 59
if score < 60:
    print('抱歉,考试不及格')
else:
    if score >= 90:
        print('恭喜你,拿到卓越的成绩')
    else:
        if score >= 80:
            print('恭喜你,拿到优秀的成绩')
        else:
            print('恭喜你,考试及格')
score = 59
if score < 60:
    print('抱歉,考试不及格')
elif score >= 90:
    print('恭喜你,拿到卓越的成绩')
elif score >= 80:
    print('恭喜你,拿到优秀的成绩')
else:
    print('恭喜你,考试及格')

特别注意: 这一系列条件判断会从上到下依次判断,如果某个判断为 True,执行完对应的代码块,后面的条件判断就直接忽略,不再执行了。

循环语句

while循环

输出0~99

i = 0
while i < 100:
    print(f"i = {i}")
    i += 1

for循环

for 临时变量 in 待处理数据集:
    循环满足条件时执行的代码

将待处理数据集中的数据挨个取出,每一次循环就将当前数据赋予这个临时变量,在循环体中使用

str = "Hello"
for x in str:
    print(x)
"""
H
e
l
l
o
"""
  • 无法定义循环条件
  • 只能从待处理的数据集中,依次取出内容进行处理
  • 理论上讲Python的for循环无法构建无限循环(被处理的数据集不可能无限大)

待处理数据集,严格来说称之为:序列类型
序列类型指:其内容可以一个个依次取出的一种类型,包括:

  • 字符串
  • 列表
  • 元组

range语句

生成数字序列

  1. range(num):获取一个从0开始,到num结束的数字序列(不含num本身)
    如:range(5)取得的数据是:[0,1,2,3,4]
  2. range(num1, num2):获取一个从num1开始,到num2结束的数字序列(不含num2本身)
    如:range(5, 10)取得的数据是:[5,6,7,8,9]
  3. range(num1, num2, step):获取一个从num1开始,到num2结束的数字序列(不含num2本身),数字之间的步长为step(step默认为1)
    如:range(5, 10, 2)取得的数据是:[5,7,9]

在for循环外部可以访问临时变量,但在编程规范上是不允许这样做的

for x in range(10):
   print(f"{x} ",end="")
print(x)
# 0 1 2 3 4 5 6 7 8 9 9

如果想访问for循环内部变量,则应该在for循环外部预先定义

x = 0
for x in range(10):
   print(f"{x} ",end="")
print(x)
# 0 1 2 3 4 5 6 7 8 9 9

for循环相当于对x进行了10次内容覆盖

continue和break

  • continue:中断本次循环,直接进入下一次循环
  • break:直接结束循环
  • 在嵌套循环中,只能作用在所在的循环上,无法对上层循环起作用

函数

定义

def 函数名(传入参数):
    函数体
    return 返回值
  • 必须先定义后使用、参数不需要可省略、返回值不需要可省略

传入参数
功能:在函数进行计算的时候,接受外部(调用时)提供的数据

def add(x, y):
    result = x + y
    print(f"{x} + {y}的计算结果是:{result}")
add(1,2)
  • 函数定义中提供的x和y,称之为形式参数,参数之间使用逗号分隔
  • 函数调用中提供的1和2,称之为实际参数,按顺序传入,使用逗号分隔

返回值

def add(a, b):
    result = a + b
    return result


r = add(1, 2)
print(r)
  • 多个返回值返回Tuple
  • 无返回值返回None

说明文档
在函数体之前通过多行注释的形式,对函数进行说明解释

pycharm在函数名之后输入"""回车会自动补全注释

def add(x, y):
    """

    :param x:
    :param y:
    :return:
    """
    result = x + y
    return result
def add(x, y):
    """
    add函数可以接收2个参数,进行2数相加的功能(整体说明)
    :param x:形参x表示相加的其中一个数字(参数说明)
    :param y:形参y表示相加的另一个数字
    :return:返回值是2数相加的结果(返回值说明)
    """
    result = x + y
    return result

鼠标悬停可以查看文档
【Python】基础内容_第2张图片

变量作用域

局部变量:在函数体内定义的变量,只能在函数体内使用
全局变量:在函数体外定义的变量,函数体内外都能使用

以下示例中,test函数内部相当于重新定义了一个num变量赋值为500,此时函数外部的num变量并没有被修改

num = 100


def test():
    num = 500
    print(num)


test()
print(num)
# 500
# 100

要想在函数内部修改全局变量需要使用global关键字

global:在函数内部声明变量为全局变量
此时test()中的num和函数外的num就是同一个变量了

num = 100


def test():
    global num
    num = 500
    print(num)


test()
print(num)
# 500
# 500

数据容器

一种可以容纳多份数据的数据类型,容纳的每一份数据称之为一个元素,每一个元素可以是任意类型的数据,如字符串、数字、布尔等。

列表(list)

可以容纳多个元素(上限为2**63-1)
可以容纳不同类型的元素
数据有序存储(有下标序号)
允许重复数据存在
可以修改、增加或删除元素

基本语法
以[]作为标识,列表内每一个元素之间用逗号隔开
元素可以为不同的数据类型,支持嵌套

# 定义列表
list1 = [1, 2, True, "hello"]

# 定义空列表
list2 = []
list3 = list()

下标索引
从前向后:从0开始,依次递增
从后向前:从-1开始,依次递减

list1 = [1, 2, True, "hello", [1, 2, 3]]

print(list1[0])  # 1
print(list1[-1][1])  # 2

  • 列表.index(元素):查找某元素在list中第一次出现的位置
  • 列表[下标]=值:修改特定索引的元素值
  • 列表.insert(下标,元素):在指定的下标位置,插入指定的元素
  • 列表.append(元素):将指定元素追加到列表的尾部
  • 列表.extend(其它数据容器):将其它数据容器的内容取出,依次追加到列表尾部
  • del 列表[下标]:删除指定位置元素
  • 列表.pop(下标):删除指定位置元素并返回
  • 列表.remove(元素):删除某元素在列表中的第一个匹配项
  • 列表.clear():清空列表内容
  • 列表.count(元素):统计某元素在列表内的数量
  • len(列表):统计列表内有多少元素

元组(tuple)

元组与列表类似,最大的不同点在于:元组一旦定义完成,就不可修改

基本语法
使用小括号定义,元素之间使用逗号分隔,数据可以是不同的数据类型

# 定义元组
tuple1 = (1, 2, "hello", [1, 2], (3, 4))
# 定义空元组
tuple2 = ()
tuple3 = tuple()

注意:如果元组只有一个数据,这个数据后面要添加逗号,否则不是元组类型

tuple1 = (1)
print(type(tuple1)) # int
tuple2 = (1,)
print(type(tuple2)) # tuple

元组的操作方法和列表相同,但是不能增加/删除/修改元素
注意:元组的内容不能修改,但是可以修改元组中嵌套的list的内容

tuple1 = (1, [1, 2, 3])
tuple1[1][1] = 1
print(tuple1)   # (1, [1, 1, 3])

字符串(string)

一个字符串可以存放任意数量的字符

下标索引
从前向后,下标从0开始
从后向前,下标从-1开始

注意:同元组一样,字符串是一个无法修改的容器,如果想要修改/删除/追加字符只能通过建一个新的字符串。


  • 字符串.index(字符串):查找特定字符串的下标索引值
  • 字符串.replace(字符串1,字符串2):将字符串内的全部字符串1替换为字符串2,这里不是修改字符串本身,而是得到一个新的字符串
  • 字符串.split(分隔符字符串):按照指定的分隔符字符串,将字符串划分为多个字符串,并存入列表对象中,字符串本身不变,而是得到了一个列表对象
  • 字符串.strip():去掉前后空格
  • 字符串.strip(字符串):去除前后指定字符串,这里不是严格按照字符串来去除的,而是把其划分为小字符串,如传入“12”,则字符串前后的“12”和“21”都会被去除
  • 字符串.count(字符串):统计字符串内某字符串出现的次数
  • len(字符串):统计字符串的字符个数

序列的切片操作

序列:内容连续、有序,可使用下标索引的一类数据容器(列表、元组、字符串)
切片:从一个序列中,取出一个子序列
语法:序列[起始下标:结束下标:步长]

  • 起始下标表示从何处开始,留空视作从头开始
  • 结束下标表示何处结束(不含),留空视作截取到结尾
  • 步长:依次取元素的间隔,步长为负数表示反向取(起始下标和结束下标也要反向标记),省略步长为1

此操作不会影响序列本身,而是会得到一个新的序列

[::-1]:表示将序列反转

集合(set)

不支持重复元素且内容无序

基本语法

使用{}定义
空集合使用set()定义,不能使用{},{}是字典

# 定义集合变量
set1 = {1, 2, "hello"}
# 定义空集合
set2 = set()

不能使用下标取元素,但是集合和列表一样可以修改

  • 集合.add(元素):将指定元素添加到集合内,集合本身被修改
  • 集合.remove(元素):将指定元素从集合内移除
  • 集合.pop():从集合中随机取出一个元素,返回一个元素,同时元素被移除
  • 集合.clear():清空集合
  • 集合1.difference(集合2):取集合1和集合2的差集(集合1有而集合2没有),得到一个新的集合,集合1和集合2不变
  • 集合1.union(集合2):将集合1和集合2合成新集合
  • len(集合):统计集合元素数量

集合不支持下标索引,不能用while循环遍历,可以用for循环

set1 = {1, 2, "hello"}
for i in set1:
    print(i)

字典(dict)

基本语法
使用{}定义,不过存储的元素是一个个的:键值对

# 定义字典变量
dict1 = {"zhangsan": 30, "lisi": 40, "wangwu": 50}
# 定义空字典
dict2 = {}
dict3 = dict()

字典不允许key重复,重复添加会把前面的覆盖掉

# 定义字典变量
dict1 = {"zhangsan": 30, "zhangsan": 40, "wangwu": 50}
print(dict1["zhangsan"]) # 40

不可以通过下标索引,可以通过key值来取得对应的value

key和value可以是任意数据类型(key不可为字典)

  • 字典[key] = value:key不存在新增元素,key存在更新元素
  • 字典.pop(key):获取指定key的value,同时key的数据被删除
  • 字典.clear():清空字典
  • 字典.keys():得到字典中的全部key,可以用来遍历字典

遍历字典:可以首先通过keys获取字典中的全部key进行遍历,也可以for循环遍历每次取得的就是字典的key

总结

  • 是否支持下标索引
    • 支持:列表、元组、字符串 - 序列类型
    • 不支持:集合、字典 - 非序列类型
  • 是否支持重复元素:
    • 支持:列表、元组、字符串 - 序列类型
    • 不支持:集合、字典 - 非序列类型
  • 是否可以修改
    • 支持:列表、集合、字典
    • 不支持:元组、字符串

【Python】基础内容_第3张图片


通用操作

遍历

  • 五类数据容器都支持for循环遍历
  • 列表、元组、字符串支持while循环,集合、字典不支持(无法下标索引)

【Python】基础内容_第4张图片

函数进阶

多返回值

多个返回值之间用逗号隔开

支持不同类型的数据return

  • 可以使用1个变量接受多返回值,返回类型为tuple
  • 可以使用多个变量分别接受各个返回值,接受变量必须与返回值一一对应
def test_return():
    return 1, 2
t = test_return()
print(type(t))  # 
print(t)        # (1, 2)
x, y = test_return()
print(x, y)     # 1 2

传参方式

位置参数

调用函数时根据函数定义的参数位置来传递参数

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('TOM', 20, '男')

关键字参数

函数调用时通过“键=值”的形式传递参数

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info(gender='女', name='Alice', age=25)

可以不固定顺序
可以和位置参数混用,位置参数必须在前,且匹配参数顺序

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')
user_info('Alice', gender='女', age=25)

你可能感兴趣的:(Python,python,开发语言)