python 语法基础篇

标识符

变量名、函数名、类名等统称为标识符

命名规范：

• 只能包含字母、数字、下划线

• 不能以数字开头

• 严格区分大小写

• 不能与系统关键字相同：keyword

  系统关键字：

  >>> import keyword
  >>> print(keyword.kwlist)
  ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
  >>> 
  

• 不能与内置函数、模块名相同

• 尽量使用有意义的英文单词

• 变量名、函数名一般使用小写字母，类名一般使用大写字母开头的英文单词

变量

变量是一种使用方便的占位符，来源于数学，是计算机语言中能储存计算结果或能表示值的抽象概念，用于引用计算机内存地址，该地址可以存储Script运行时可更改的程序信息。

变量可以保存程序运行时用户输入的数据、特定运算的结果等。简而言之，变量是用于跟踪几乎所有类型信息的简单工具。

python中声明变量非常简单，一句话概括就是，起个名字，给个值

变量命名方式

• 驼峰命名法

  # 第一个单词小写，后面的每个单词首字母大写
  studentName = '李四'
  

• 下划线分隔法（推荐）

  # 多个单词间使用下划线连接
  student_name = '李四'
  

  例：

  a,b,c = 1,2,3     # 声明3个变量，并分别赋值为1，2，3
  a = 1,2,3,4,5     # 将多个值封包到一个元组中，赋值给变量
  a,b = b,a         # 交换2个变量的值
  

注释

python 中的注释分为单行注释和多行注释

单行注释：#

多行注释：“somthing” 或者"““somthing””"

c = 1,2,3,4,5
print(c)
# name = '张三'
"""
多行注释
good
abc
"""
address = """
            长字符串
            贵州省
            黔东南
            dasfsdg
            asdasdasdsdf
            asd
            """
print(address)

输入输出

1、输入输出

（1）输入

语法：input(['message'])

input函数用于接收外部的输入，所有输入都作为字符串处理

代码运行到input语句时会暂停，直到点击回车键

name=input("请输入姓名: ")
print(name,type(name))

(2) 输出

语法：print(value1.value2,....[,sep='x',end='x'])

value,待输出的值，可以同时输出多个

sep,输出多个值时，每个值之间的分隔符默认为空格

end，输出完成后的结尾符号，默认为换行符\n，如果想要输出后不换行可以用end="

name = input("请输入姓名： ")
age = input("请输入年龄: ")
print('*'*50)
print(name,age,sep=',',end='')

占位符

方式一：

语法：%[-w.p]type

-，表示左对齐，默认是右对齐

w,宽度

p，表示精度，主要用于浮点型数据

type，表示数据类型（d -整数，f-浮点数, s -字符串）

name = '杨玉'
age = 20
weight = 50.978
print('姓名：%s, 年龄：%d, 体重：%.2f' %(name,age,weight))
print('-'*50)
print('姓名:%-8s\n年龄：%-8d\n体重:%8.1f' %(name,age,weight))
# 注意：使用时占位符与值必须要一一对应

方式二: format

语法：'{[:w.pf]}' .format(value)

w,宽度

pf,表示精度，主要用于浮点型数据

<左对齐

^，居中对齐

name = '杨雨'
age = 20
weight = 60.412
print('姓名：{}\n年龄：{}\n体重：{}' .format(name,age,weight))
print('*'*50)
print('姓名:{:8}\n年龄：{:<8}\n体重:{:^8.2f}' .format(name,age,weight))

方式三： f-string

语法：f'{var[:w.pf]}'

w,宽度

pf,表示精度，主要用于浮点型数据

>，右对齐

^,居中对齐

name = '杨玉'
age = 20
weight =50.987
print（f'姓名：{name}, 年龄:{age},体重:{weight}')
print('*'*50)
print(f'姓名：{name:^80}\n年龄:{age:>80}\n体重:{weight:.1f}')

数据类型

函数 ：type(obj)

数字型

都为不可变数据类型

整型：int

浮点型：float

布尔型：bool

值为：True 、False

字符串

不可变数据类型

声明：字符是包含在引号之间的内容，可以一对单引号、双引号、三引号

字符串方法：

语法：obj.function([参数])

upper(),将字符串转换为大写，返回一个新的字符

lower()，将字符串转换为小写，返回一个新的字符

title()，将字符串中单词的首字母转换为大写，其余字母小写，返回一个新的字符

例1：

name ='maria_db'
print(name.upper())
print(name.lower())
print(name.title())

count(sub[start[,end]])，统计在指定位置之间子字符串的数量

sub,待统计的子字符串

start，开始位置的索引（第一个位置索引为0，最后一个位置索引为-1）省略表示从索引为0开始

end，结束位置的索引（第一个位置索引为0，最后一个位置索引为-1，省略表示到索引为-1结束

name = 'maria_db'
print(name.count('a'))
print(name.count('a',2))
print(name.count('a',1,-3))

index(sub[start[,end]]),返回子字符串在字符串中第一次出现的位置（索引）

不包含子字符串时提示错误

replace(sub,new[,count]),将字符串中指定的字符串替换为新内容，可以通过count指定替换次数，返回一个新的字符串

name = '张阳阳'
print(name.replace('阳','*')
print(name.replace('阳','*',1))

strip(),去除字符串两边的空字符(空格、\n、\t），返回一个新的字符串

split([sub]),将一个字符串使用指定的子字符串进行分隔，返回一个列表，默认使用空格进行分割

name = 'abc ef,g\tm,np'
print(name.split())
print(name.split(','))

join(itea),将一个可迭代对象转换为字符串

li = ['abc', 'ef,g' 'm,np']
print(''.join(li))
print(','.join(li))
print('\t\t'.join(li))

isupper()，检查字符串是否全为大写，如果是返回True,否则返回False

islower(),检查字符串是否全为小写，如果是返回True,否则返回False

isalnum(),检查字符是否由字母或者数字组成，如果是返回True,否则返回False

isalpha(),检查字符是否由字母组成，如果是返回True，如果不是返回False

isdecimal(),检查字符是否由数字组成，如果是返回True,如果不是返回False

encode(),编码

decode()，解码

startswith(),检查字符串是否以指定内容开头，如果是返回True,否则返回False

endswith(),检查字符串是否以指定内容结束，如果是返回True,否则返回False

列表

• 声明：包括在一对[]之间，每个元素之间使用逗号隔开，元素可以为任意数据类型
• 内置方法：
  • index(obj)，返回指定元素在列表中的索引，如果指定元素不存在则报错
  • count(obj)，返回指定元素在列表中的数量，如果指定元素不存在则返回0
  • append(obj)，将一个对象添加到列表末尾
  • insert(index,obj)，在指定索引处添加一个对象
  • extend(iter)，将一个可迭代对象的元素分别添加到列表
  • 例：添加元素

li = []    # 声明一个空列表
li.append(1)    # [1]
print(li)
li.append((1,2,3,4))   # [1, (1, 2, 3, 4)]
print(li)
li.insert(0,['a','b','c'])  # [['a', 'b', 'c'], 1, (1, 2, 3, 4)]
print(li)
li.extend('abc')  # [['a', 'b', 'c'], 1, (1, 2, 3, 4), 'a', 'b', 'c']
print(li)

• pop([index])，删除指定索引处的元素，默认删除最后一个元素
• remove(obj)，删除指定元素，如果存在多个相同的元素，删除的是索引最小处的元素（从左往右数的第一个）
• clear()，清空列表
  例：删除元素

li = [1,1,2,3,1,4,1,5,6]    # 声明一个列表
li.pop()   # 删除最后一个元素
print(li)  # [1,1,2,3,1,4,1,5]
li.pop(2)  # 删除指定索引处的元素
print(li)  # [1, 1, 3, 1, 4, 1, 5]
li.remove(1)
print(li)  # [1, 3, 1, 4, 1, 5]
li.remove(1)
print(li)  # [3, 1, 4, 1, 5]
li.clear()
print(li)  # []

• sort([key=xxx,reverse=True])，排序
  • key，指定排序内容
  • reverse=True，指定为降序
• reverse()，将列表元素反向
• copy()，复制列表(在内存中开辟新地址保存相同内容)

li = [['a',100],['d',97],['b',99]]    # 声明一个列表
a = li  # 将变量li保存的地址赋值给变量a
print(a == li)  # True
print(a is li)  # True
b = li.copy()  # 在内存中新开辟地址保存列表li的内容，将新地址赋值给变量b
print(b == li)  # True
print(b is li)  # False
print(id(a),id(li),id(b))  # 140301576496064 140301576496064 140301576496384

字典

• 声明：包括在{}之间，元素以键值(key:value)对形式存在，key必须为不可变数据类型，value可以是任意数据类型
  操作：
• 新增键值对：dic[key] = value，如果key不存在，则新增键值对
• 修改值：dic[key] = value，key存在
• 访问键值对：dic[key]

dic = {'name':'张三',('age',):20,100:[1,2,3,4],True:1,3.14:'PI'} # 声明字典
# 字符串、元组、int、float、bool属于不可变类型，可以作为字典的键
print(dic)
print(dic['name'])  # 访问键值对
dic['name'] = '李四'  # 键'name'存在，则完成修改动作
print(dic)
dic['phone'] = '13512345678'  # 新增键值对
print(dic)

内置方法

• get(key)，返回指定键的值，如果key不存在，返回None
• update(key=value)，新增键值对，如果key存在则实现修改动作

dic = {'a':1,'b':2} # 声明字典
dic.update(c=3)   # {'a': 1, 'b': 2, 'c': 3}
print(dic)
dic.update(a=3)   # {'a': 3, 'b': 2, 'c': 3}
print(dic)

setdefault(key,value)，如果key存在，返回对应的值；如果key不存在，则在字典中新增键值对，返回value

dic = {'a':1,'b':2} # 声明字典
print(dic.setdefault('a',100))    # 1
print(dic.setdefault('aaa',100))  # 100
print(dic)    # {'a': 1, 'b': 2, 'aaa': 100}

• pop(key)，删除指定键值对
• popitem()，随机删除一个键值对
• keys()，以dict_keys格式返回字典中所有的键
• values()，以dict_values格式返回字典中所有的值

元组

• 不可变数据类型
• 声明：包括在一对()之间，每个元素之间使用逗号隔开，元素可以为任意数据类型
  注意：如果元组只有1个元素，必须在该元素后面加逗号
• 内置方法
  • index(obj)，返回指定元素在元组中的索引，如果指定元素不存在则报错
  • count(obj)，返回指定元素在元组中的数量，如果指定元素不存在则返回0

集合

声明：包括在{}之间，元素可以时任意数据类型，集合中过的元素是唯一的

set(obj)，将一个可迭代对象转换为集合，自动去重

数据类型转换

int(obj),转换为整型

float(obj),转换为浮点型

bool(obj)，转换为布尔型

str(obj), 转换为字符串

list(obj）,将可迭代对象转换为列表

可迭代对象

• 内置方法中包含_ _iter_ _方法对象称为可迭代对，主要有str、list、tuple、dict、set

• 元素访问

  • 支持循环遍历（for循环）
  • str、list、tuple：通过索引访问元素
    • 索引从0开始，可以为负数
  • dict：通过key访问键值对

• 切片操作

  • str、list、tuple支持切片操作，用于获取对象的元素片段
  • 字符串切片返回字符串，列表切片返回列表
    语法：obj[[start]:[end][:step]]

• start，开始为位置的索引，如果省略表示索引为0，包括在结果中

• end，结束位置的索引，如果省略表示索引为-1。end索引处的元素不包括在结果中

• step，步长，表示间隔多少个元素取一个，默认步长为1（表示依次取）
  例：

li = [1,2,3,4,5,6,7,8]
print(li[1:5])  # [2, 3, 4, 5]
print(li[1:5:2])  # [2, 4]
print(li[1:])  # [2, 3, 4, 5, 6, 7, 8]
print(li[:])  # [1, 2, 3, 4, 5, 6, 7, 8]
print(id(li),id(li[:]))
a = li[::-1]  # [8, 7, 6, 5, 4, 3, 2, 1]
print(a)
print(li)

通用方法

• len(iter)，返回可迭代对象中的元素数量
• sum(iter)，返回可迭代对象中所有元素的和
• max(iter)，返回最大值
• del iter，删除指定对象

li = [1,2,3,4,5,6,7,8,9]
print(len(li))  # 9
print(sum(li))  # 45
print(max(li))  # 9
del li[0]  # 删除列表的第一个元素
print(li)   # [2, 3, 4, 5, 6, 7, 8, 9]
del li[4:]  # 删除列表中第5个元素开始的所有内容
print(li)    # [2, 3, 4, 5]
del li    # 删除列表

运算符

算数运算符

• +，返回两个对象的和，参数运算符的对象数据类型为int或者float

  如果参与运算的对象为两个字符串，实现的是字符串拼接

• -，返回两个对象的差，参数运算符的对象数据类型为int或者float

• *，返回两个对象的乘积，参数运算符的对象数据类型为int或者float

  如果参与运算的对象为一个整数一个字符串，实现的是将字符串复制n次

• /，返回两个对象的商，参数运算符的对象数据类型为int或者float

• //，整除（地板除），返回小于等于两个对象商的最大整数（向下取整）

        5//2 = 2
        5//-2 = -3
  

• %，返回两个对象相除的余数

        公式：`r = a%b = a-b*(a//b)`
        5%2 = 1
        5%-2 = -1
  

• **，幂运算

       3**2 = 9
       3**0.5 = 1.73
  

例1：输入1个四位的正整数，计算出这个数每一位上数字的和

# 方法一：通过索引获取每一位上数字
number = input('请输入1个四位正整数：')
# 获取每一位上的数字
# 通过索引获取每一位上的数字
unit = int(number[-1])      # 个位数
ten = int(number[-2] )      # 十位
hun = int(number[1])        # 百位
th = int(number[0])         # 千位
# 求和
s = unit+ten+hun+th
print(f'{number}每一位上数字的和为：{s}')

# 方法二：通过算术运算获取每一位上数字
number = input('请输入1个四位正整数：')
number = int(number)
# 获取每一位上的数字
unit = number%10      # 个位数
ten = number%100//10     # 十位
hun = number%1000//100        # 百位
th = number//1000         # 千位
# 求和
s = unit+ten+hun+th
print(f'{number}每一位上数字的和为：{s}')

例2：有一个列表students中保存有学生的成绩信息—[[1001,'张三',89,90,91,270,90.00],[1002,'李四',89,90,91,270,90.00]]，每个学生的成绩存在一个子列表中，依次表示学号、姓名、语文、数学、英语、总分、平均分。输入一个新的学生学号、姓名和各科成绩，其总分和平均分计算出来后保存到列表students中

students = [[1001,'张三',89,90,91,270,90.00],[1002,'李四',89,90,91,270,90.00]]
tmp = []   # 保存每一个学生信息
no = int(input('学号：'))
name = input('姓名：')
ch = int(input('语文：'))
mth = int(input('数学：'))
eng = int(input('英语：'))
total = ch+mth+eng    # 总分
avg = f'{total/3:.2f}' # 平均分
tmp = [no,name,ch,mth,eng,total,float(avg)]
students.append(tmp)
print(students)

赋值运算符

• =
• +=，如a += 1相当于a = a+1
• -=
• *=
• /=
• //=
• %=
• **=

比较运算符

运算结果为True或者False

• ==，判断两个对象的值是否等
• !=
• >
• >=
• <
• <=

逻辑运算符

• 运算结果为True或者False

• and，参与运算的两个对象结果都为True，则整体表达式结果为True，否则结果为False

  左边表达式结果为False时，右边表达式不会运行

a,b,c = 10,20,30
tmp = a>10 and (b:=21)>20 # a>10结果为False，(b:=21)>20表达式不运行，故b的值不变
print(tmp)
print(b)   # 20

• or，参与运算的两个对象结果都为False，则整体表达式结果为False，否则结果为True
  - 左边表达式结果为True时，右边表达式不会运行

a,b,c = 10,20,30
tmp = a>1 or (b:=21)>20 # a>1结果为True，(b:=21)>20表达式不运行，故b的值不变
print(tmp)
print(b)  # 20

• not，参与运算的对象结果为False，则整体表达式结果为True，否则结果为False

成员运算符

运算结果为True或者False

• in，

  'name' in ['name','age'] = True

  'a' in {'a':1,'b':2} = True，检查的是键

• not in

三元运算符

• 语法：value1 if 布尔表达式 else value2，如果布尔表达式结果为True，返回value1，否则返回value2
  例1：输入一个学生的姓名、成绩，如果成绩大于等于60，输出合格，否则输出不合格

name = input('姓名：')
score = int(input('成绩：'))
result = '合格' if score >= 60 else '不合格'
print(f'姓名：{name}\t成绩：{result}')

例1：输入一个学生的姓名、成绩，如果成绩大于等于90，输出A，成绩在[70,89]，输出B，在[60,69]，输出C，小于60输出D

name = input('姓名：')
score = int(input('成绩：'))
result = 'A' if score >= 90 else ('B' if score >= 70 else ('C' if score >= 60 else 'D'))
print(f'姓名：{name}\t成绩：{result}')

身份运算符

检查两个对象是否引用同一个地址，运算结果为True或者False

• is
• not is

位运算符

<<