蓝桥杯系列2——python基本语法

简介: 蓝桥杯系列2——python基本语法

看课本收货良多,因此对照菜鸟教程把python基本语法对着敲了一下。

这部分看起来很多,但实际只花了一个下午。写给自己以后复习看。

你好,世界

print ("你好,世界")
你好,世界

Python 变量类型

变量存储在内存中的值,这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。

因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。

变量赋值

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。

每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print(counter,miles,name)
100 1000.0 John

多变量赋值

a, b, c = 1, 2, "john"
print(a,b,c)
1 2 john

标准数据类型

在内存中存储的数据可以有多种类型。

例如,一个人的年龄可以用数字来存储,他的名字可以用字符来存储。

Python 定义了一些标准类型,用于存储各种类型的数据。

Python有五个标准的数据类型:

不可变:Numbers(数字)

String(字符串)

List(列表)

Tuple(元组)

Dictionary(字典)

数字

数字数据类型用于存储数值。

他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。

当你指定一个值时,Number 对象就会被创建:

var1 = 1
var2 = 10
del var1 # 删除单个或多个对象的引用
var1
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_21312/2376987541.py in <module>
----> 1 var1
NameError: name 'var1' is not defined

Python支持四种不同的数字类型:

int(有符号整型)

long(长整型,也可以代表八进制和十六进制) 0122L

float(浮点型)

complex(复数) 4.53e-7j

字符串

[头下标:尾下标] 来截取相应的字符串,从 0 开始。

[头下标:尾下标] 获取的子字符串[头,尾)。

访问字符串的值

s = 'abcdef'
s[1:5]
'bcde'

字符串连接

加号(+)是字符串连接运算符,星号(*)是重复操作。

str = 'Hello World!'
print (str )          # 输出完整字符串
print (str[0])        # 输出字符串中的第一个字符
print (str[2:5] )     # 输出字符串中第三个至第六个之间的字符串
print (str[2:]  )     # 输出从第三个字符开始的字符串
print (str * 2 )      # 输出字符串两次
print (str + "TEST")  # 输出连接的字符串
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

列表截取第三个参数:截取的步长

letters='abcdefg'
letters[1:4:2]
'bd'

列表

List(列表)用 [ ] 标识,支持字符,数字,字符串甚至可以包含列表(即嵌套)。

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print (list  )             # 输出完整列表
print (list[0]  )          # 输出列表的第一个元素
print (list[1:3]  )        # 输出第二个至第三个元素 
print (list[2:]  )         # 输出从第三个开始至列表末尾的所有元素
print (tinylist * 2 )      # 输出列表两次
print (list + tinylist)    # 打印组合的列表
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

元组

用 () 标识。内部元素用逗号隔开。

不能二次赋值,相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print (tuple   )            # 输出完整元组
print (tuple[0]   )         # 输出元组的第一个元素
print (tuple[1:3]  )        # 输出第二个至第四个(不包含)的元素 
print (tuple[2:]   )        # 输出从第三个开始至列表末尾的所有元素
print (tinytuple * 2   )    # 输出元组两次
print (tuple + tinytuple)   # 打印组合的元组
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

字典

字典(dictionary)。列表是有序的对象集合,字典是无序的对象集合。

两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print (dict['one']  )        # 输出键为'one' 的值
print (dict[2])              # 输出键为 2 的值
print (tinydict )            # 输出完整的字典
print (tinydict.keys())      # 输出所有键
print (tinydict.values()   ) # 输出所有值
This is one
This is two
{'name': 'runoob', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['runoob', 6734, 'sales'])

数据类型转换

需要对数据内置的类型进行转换,数据类型作为函数名。

返回一个新的对象,表示转换的值。

函数 描述

int(x [,base]) 将x转换为一个整数

long(x [,base] ) 将x转换为一个长整数

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

complex(real [,imag]) 创建一个复数

str(x) 将对象 x 转换为字符串

repr(x) 将对象 x 转换为表达式字符串

eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s) 将序列 s 转换为一个元组

list(s) 将序列 s 转换为一个列表

set(s) 转换为可变集合

dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。

frozenset(s) 转换为不可变集合

chr(x) 将一个整数转换为一个字符

unichr(x) 将一个整数转换为Unicode字符

ord(x) 将一个字符转换为它的整数值

hex(x) 将一个整数转换为一个十六进制字符串

oct(x) 将一个整数转换为一个八进制字符串

运算符

算术运算符

比较(关系)运算符

赋值运算符

逻辑运算符

位运算符

成员运算符

身份运算符

运算符优先级

  • / % ** //
    除数为浮点数,结果才为浮点数
a = 21
b = 10
c = 0
c = a + b
print ("1 - c 的值为:", c)
c = a - b
print ("2 - c 的值为:", c )
c = a * b
print ("3 - c 的值为:", c )
c = a / b
print ("4 - c 的值为:", c )
c = a % b
print ("5 - c 的值为:", c)
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为:", c)
a = 10
b = 5
c = a//b 
print ("7 - c 的值为:", c)
1 - c 的值为: 31
2 - c 的值为: 11
3 - c 的值为: 210
4 - c 的值为: 2.1
5 - c 的值为: 1
6 - c 的值为: 8
7 - c 的值为: 2

位运算

按位运算符是把数字看作二进制来进行计算的。

& 与 | 或 ^ 异或 ~ 取反 << 左移(高位丢弃,低位补零) >> 右移

逻辑运算

and or not 返回布尔值

成员运算符

in

返回布尔值

not in

判断:是否同一内存空间

条件语句

通过一条或多条语句的执行结果(True或者False)来决定执行的代码块。

条件之间,and或者or连接

if elif else

循环语句

while for 嵌套

while 1: #循环必然成立,靠break跳出循环

循环控制语句

break跳出当个循环 continue跳出当次循环 pass占位语句

continue 语句是一个删除的效果,他的存在是为了删除满足循环条件下的某些不需要的成分

pass定义空函数

def sample(n_samples):

pass

循环使用else语句

while … else 在循环条件为 false 时执行 else 语句块

count = 0
while count < 5:
    print( count, " is  less than 5")
    count = count + 1
else:
    print( count, " is not less than 5")
0  is  less than 5
1  is  less than 5
2  is  less than 5
3  is  less than 5
4  is  less than 5
5  is not less than 5

Number(数字)

不允许改变,改变数值将重新分配内存空间

math 模块、cmath 模块

math 模块提供了许多对浮点数的数学运算函数。

cmath 模块包含了一些用于复数运算的函数。

# 查看 math 查看包中的内容:
import math
dir(math)
['__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'acos',
 'acosh',
 'asin',
 'asinh',
 'atan',
 'atan2',
 'atanh',
 'ceil',
 'comb',
 'copysign',
 'cos',
 'cosh',
 'degrees',
 'dist',
 'e',
 'erf',
 'erfc',
 'exp',
 'expm1',
 'fabs',
 'factorial',
 'floor',
 'fmod',
 'frexp',
 'fsum',
 'gamma',
 'gcd',
 'hypot',
 'inf',
 'isclose',
 'isfinite',
 'isinf',
 'isnan',
 'isqrt',
 'lcm',
 'ldexp',
 'lgamma',
 'log',
 'log10',
 'log1p',
 'log2',
 'modf',
 'nan',
 'nextafter',
 'perm',
 'pi',
 'pow',
 'prod',
 'radians',
 'remainder',
 'sin',
 'sinh',
 'sqrt',
 'tan',
 'tanh',
 'tau',
 'trunc',
 'ulp']

数学函数

函数 返回值 ( 描述 )

abs(x) 绝对值,如abs(-10) 返回 10

cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

exp(x) e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x) 浮点数绝对值,如math.fabs(-10) 返回10.0

ceil(x) 上入整数,如math.ceil(4.1) 返回 5

floor(x) 下舍整数,如math.floor(4.9)返回 4

log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x) 以10为基数的x的对数,如math.log10(100)返回 2.0

max(x1, x2,…) 最大值,参数可以为序列。

min(x1, x2,…) 最小值,参数可以为序列。

modf(x) x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。

pow(x, y) x ** y 运算后的值

round(x [,n]) 浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。

sqrt(x) 数字x的平方根## 随机函数

choice(seq) 从序列元素中随机挑选一个元素,如random.choice(range(10)),从0到9中随机取一个整数

randrange([start,] stop [,step])从指定基数递增集合获取一个随机数

random() 随机生成一个实数,[0,1)范围内

seed([x])改变随机数生成的种子seed

shuffle(lst) 将序列的所有元素随机排序

uniform(x,y) 随机生成下一个实数,在[x,y]范围内

三角函数

asin(x) 反余弦弧度值

数学常量

pi

e

字符串

var[2:5] [2,5)

var1[:6] + 'Runoob!

转义字符

\b 退格

\000 空

\v 纵向制表符

\t 横向制表符

\r 回车

print('\000'+'1')
print('1')
1
1
  • 连接 * 重复输出 in 包含返回True r 原始字符串
print(r'\n')
\n

格式化输出

print("My name is %s and weight is %d kg!" % ('Zara',21))
My name is Zara and weight is 21 kg!

格式化符号

%c ASCII码

%s 字符串

%d 整数

%u 无符号整数

%o 八进制 %x 十六进制 %X 大写十六进制

%f 浮点数字,可指定精度

%e 科学计数法表示浮点数

% 十六进制输出变量地址

格式化操作符辅助指令

  • 宽度获小数点精度
  • 左对齐
  • 正数前面显示+
    正数前面显示空格

八进制数前面显示(‘0’)

0 显示数字前面填充’0’而不是默认空格

%% 输出%

(var) 映射变量

m.n. m显示最小总宽度,n是小数点位数

str.format 格式化函数string.capitalize() 字符串第一个字符大写

string.count() 返回出现次数

string.find() 检测是否包含

string.replace(str1,str2)

string.rfind() 返回最后一次出现的次数

string.upper() 转换为大写

string.lower() 转化为小写

if tmp_fun()==fun_tmp().decode("gbk"):
    print("eq")
'''
  decode("gbk")作用为将gbk编码转为unicode编码
'''

列表

list1 = ['physics', 'chemistry', 1997, 2000]
print("list1[1:5]: ", list1[1:5])
list1.append('Runoob') # 增加
print(list1)
del list1[2] # 删除
print(list1)
list1[1:5]:  ['chemistry', 1997, 2000]
['physics', 'chemistry', 1997, 2000, 'Runoob']
['physics', 'chemistry', 2000, 'Runoob']
print(list1[1:])
print(list1[-1])
print(list1[2])
['chemistry', 2000, 'Runoob']
Runoob
2000

列表函数

cmp(list1, list2) 比较两个列表的元素

len(list) 列表元素个数

max(list) 返回列表元素最大值

min(list) 返回列表元素最小值

list(seq) 将元组转换为列表

列表方法

list.append() 添加对象

list.count() 统计出现次数

list.extend() 新列表扩充原列表

list.index() 列表找出某个值第一个匹配项的索引位置

list.insert() 将对象插入列表

list.pop([index=-1]) 移除列表中的一个元素(默认最后一个元素),返回该元素的值

list.remove() 移除列表中某一个值的第一个匹配项

list.reverse() 反向列表元素

list.sort(reverse=False) 对原列表进行排序

元组

元组元素不能修改 (),隔开

tup1 = ('physics', 'chemistry', 1997, 2000)
#元组中只包含一个元素时,需要在元素后面添加逗号
tup2 = (50,)
print("tup1[0]: ", tup1[0])
tup1[0]:  physics

修改元组:可以连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
(12, 34.56, 'abc', 'xyz')

删除元组:使用del语句来删除整个元组

无关闭分隔符

任意无符号的对象,以逗号隔开,默认为元组

内置函数

tuple(seq) 将列表转换为元组

字典

可变容器,可存储任意类型对象

字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中 ,格式如下所示:

d = {key1 : value1, key2 : value2 }


目录
相关文章
|
2天前
|
C语言 Python
Python基础语法(番外篇)
Python基础语法(番外篇)
|
2天前
|
程序员 编译器 C语言
Python基础语法(内置Python, pycharm配置方式)
Python基础语法(内置Python, pycharm配置方式)
|
20天前
|
编译器 Python Windows
【Python 30天速成计划】2. 基础语法
【Python 30天速成计划】2. 基础语法
|
25天前
|
机器学习/深度学习 存储 数据挖掘
Python基础语法与常用数据类型:让编程入门更简单
在计算机科学领域,Python是一种广泛使用的高级编程语言。它的优雅语法和强大的数据类型使得Python成为了初学者、专业人士和研究人员的首选。本文主要介绍Python的基础语法和常用数据类型,帮助读者快速掌握Python编程的核心概念。
|
29天前
|
索引 Python 容器
【备战蓝桥杯】探索Python内置标准库collections的使用
【备战蓝桥杯】探索Python内置标准库collections的使用
20 1
|
29天前
|
开发者 Python
【备战蓝桥杯】如何使用Python 内置模块datetime去计算我与CSDN相遇的天数
【备战蓝桥杯】如何使用Python 内置模块datetime去计算我与CSDN相遇的天数
12 1
|
30天前
|
机器学习/深度学习 存储 人工智能
Python入门指南:从基本语法到实用技巧
Python是一种流行的编程语言,因其简单易学而备受欢迎。本文将介绍Python的基础语法和常用数据类型、函数、流程控制等概念,同时分享一些实用技巧和应用案例,帮助初学者快速上手。
|
30天前
|
数据库连接 开发者 Python
深度解析Python关键字:掌握核心语法的基石
Python关键字是一些预定义的标识符,是编程语言内建的具有特殊含义的保留字,它们在语法结构、逻辑控制、错误处理等方面执行特定的操作。Python3.12中共有35+4个关键字,作为构成python语言语法结构的核心元素,不可用作变量名、类名或函数名等。理解并熟练运用这些关键字对于编写高质量、易于理解和维护的代码至关重要。
49 2
|
30天前
|
Java 索引 Python
【Python】语法进阶
【Python】语法进阶
81 2
|
30天前
|
IDE Java C++
【Python】 基础语法
【Python】 基础语法
70 1

相关产品

  • 云迁移中心