简单使用python

本文章没有深入探讨python，只说语法格式，合适于有其他编程语言的基础、并想快速使用python的人查看。

一、print()

用于打印信息，括号中可以是数学运算表达式或者字符串（或者说是文字）。

print('hello!')

1.1、转义字符 

• 字符串：需要用引号包住，其中英文的 单引号(') 和 双引号(") ，作用是一样的
• 转义字符：反斜杠 \

\n	代表一个换行符
\‘	代表一个单引号
\"	代表一个双引号
\\	代表一个反斜杠

•  三引号：包住字符串就不需要转义特殊符号了

1.2、字符串格式化输出

加前缀f

占位符{变量表达式}

name = 'ZhangSan'
birth_year = 2000# 格式化前
print('你好，我是 ' + name + '，今年' + str(2022 - birth_year) + '岁')# 格式化后
print(f'你好，我是 {name}，今年 {2022 - birth_year} 岁')

 格式说明符：表示某个字符串输出格式

• 格式： '字符串':填充值 左右对齐 长度
• < 左对齐、> 右对齐、^ 居中对齐

# 用_填充；<左对齐、>右对齐、^居中对齐；长度为10位
print(f"{'abcd':_<10}123")
# 输出：abcd______123

print(f"{'abcd' * 2:_<10}123")
# 输出：abcdabcd__123

 1.2.1、print不支持类型自动转换

用a + b举例

a = '1'
b = 2print(a + b)
# 会报错：TypeError: cannot concatenate 'str' and 'int' objects on line 3print(int(a) + b)
# 输出：3
print(a + str(b))
# 输出：12

二、变量

用于保存临时数据的。c语言是先表明数据类型再起名字，然后再赋值；python的话可以不用表明数据类型，python再运行时可以自己确定是什么类型的数据。

变量名 = 数据

• 变量名只能由英文字母（a-z），数字（0-9）和下划线（_）共同组成
• 不能以数字开头

2.2、全局变量，需要先用global关键字声明变量，然后才能给全局变量赋上值

rent = 0def calc(n, r):# 原来的函数中 rent 只是局部变量# 与全局变量 rent 名称相同，但互不干扰# 所以要用 global 关键字将 rent 与之前的全局变量挂钩global rentrent = n * r

 三、字符串

保存文字信息的一种数据类型。

• 字符串加法拼接："字符串1" + "字符串2"
• 能使用 len() 判断字符串长度
• 支持正向和反向索引
• 不可修改
• 字符串乘法拼接："字符串1" * 3；字符串1字符串1字符串1
• "字符串1" in  "字符串2"：判断 "字符串2"是否包含 "字符串1"

 3.1、字符串常用的方法

# 全部小写
j = s.lower()# 全部大写
j = s.upper()# 首字母大写，其余小写
j = s.capitalize()# 单词首字母大写，其余小写
j = s.title()# 大写转小写，小写转大写
j = s.swapcase()# 按指定字符或字符串分割
j = s.split(',')# 按指定字符或字符串分割后并将原序列反向
j = s.split(',')[::-1]
# 例如：
# s = '1,2,3'
# j = s.split(',')[::-1]
# print(j)
# 输出：['3', '2', '1']# 移除首尾指定字符，可以同时指定多个
j = s.strip('.?')# 字符串连接、拼接
j = ','.join(['hello','hi'，'你好'])
# 'hello,hi,你好'# 统计元素出现次数
'hello'.count('l')
# 2# 返回字串最先出现的位置
s.find('he')# 返回字符最先出现的位置
s.index('h')# 将某内容替换为新内容
'hello'.replace('l','q')
# heqqo

四、整数和浮点数 int/float

+	加法
-	减法
/	除法
*	乘法
%	求余
//	整除，向下取整
**	乘方，如：3**2=9

4.1、四舍五入round()

# round(变量值, 保留的小数点位数)print(round(352.336, 2))
# 输出：352.34

4.2、位运算

&	与
|	或
^	异或
~	非
<<	左移
>>	右移

五、type()

查询数据类型

print(type(1))
# 输出：<class 'int'>

六、类型转换

str()	转换为字符串
float()	转换为浮点数
int()	转换为整型
bool()	转换为布尔类型，为空或0时为False
list()	转换为列表
tuple()	转换为元组
dict()	转换为字典

bool() 举例：

        False：bool(0)、bool('')、bool({})、bool([])

        True：bool(1)、bool(-1)、bool(' ')、bool({'a':1})、bool([1])

七、条件结构

if 判断条件1:代码块 1
elif 判断条件2:代码块 2
else:代码块 3

八、缩进

一般是两个空格或四个空格，主要用于表示前后代码之间的关系（python可以不使用花括号，而是使用缩进2个空格或4个空格去表示代码之间的所属关系等）

九、注释

 

#	单行注释
'''	内容前后都有三个单引号，多行注释
"""	内容前后都有三个双引号，多行注释

十、input()

输入函数。

input('请输入：')变量 = input('请输入：')变量 = int(input('请输入数字：'))

十一、函数的定义

def 函数名(形参1,形参2=默认值):......函数体;return 返回值1,变量1,返回值2;

形参可以不指定参数类型；

形参还可以指定默认值；

定义函数时，默认参数的位置必须在位置参数的位置之后；

# 在对象中，函数还可以加self,self不能传实参，仅使用当前对象时调用
def 函数名(self,形参1,形参2=默认值):......函数体;return 返回值1,变量1,返回值2;

十二、调用函数

函数名(实参1,实参2);函数名(形参1 = 实参1,形参2 = 实参2);

两种传参方式：1、按顺序传参；2、按关键字传参

 需要区分关键字和函数：

        关键字如：return

        函  数  如：print()

十三、布尔类型

True

False

十四、逻辑运算：与、或、非

and	与
or	或
not	非

十五、成员运算符：in、not in

print('H' in 'Hello world')
# 输出：Trueprint('a' in 'Hello world')
# 输出：False

十六、三元表达式

注意，python的三元表达式和我们在Java或其他语言中的使用习惯非常不同！！！

# 修改前：
if 条件:x_abs = 值1
else:x_abs = 值2# 修改后：
x_abs = 值1 if 条件 else 值2

十七、列表

17.1、列表基础信息

有顺序；

支持不同类型元素；

顺序索引（下标从0开始）；

也可以反向索引，如：var1[-1] 表示列表的最后一个元素；

var1 = [1, 1.0, 'hello', True]

var1 = [
1, 
1.0, 
'hello', 
True
]

 17.2、var1.index(value1)：按元素的值返回列表位置

print( var1.index('hello') )
# 输出：2

17.3、按位置（下标从0开始）修改值

var1[2] = '你好'

17.4、var1.append(value1)：列表末尾添加元素

var1.append('世界')

17.5、var1.insert(index1, value1)：插入元素

var1.insert(0, 'hi!')

17.6、var1.pop()：默认删除最后一个元素，也可以按下标位置删除

var1.pop()
# 删除末尾元素var1.pop(0)
# 删除第一个元素

17.7、del var1[index1]：删除列表中下标为index1的元素

del var1[0]

17.8、var1.remove(value1)：删除列表中值为value1的第一个元素

var1.remove('hello')

17.9、分片

var1[2:5]
# 表示索引为2、3、4，不包括5var1[-3:]
# 后三名var1[:3]
# 前三名

17.10、count()：统计次数

var1.count('hello')
# 统计hello出现的次数

17.11、sort()：排序

words = ['banana', 'apple', 'cherry']
# 默认升序
var1.sort()
var1.sort(key=None, reverse=False)# 降序
var1.sort(reverse=True)# 按长度排序
var1.sort(key=len)# 按关键字的第二个字母排序
var1.sort(key=lambda x: x[1], reverse=False)
# 输出：['banana', 'cherry', 'apple']# 按关键字的最后一个字母排序
var1.sort(key=lambda x: x[-1], reverse=False)
# 输出：['banana', 'apple', 'cherry']

17.12、reverse()：反转

var1.reverse()

17.13、copy()：复制

var2= var1.copy()

17.14、clear()：清空

var1.clear()

17.15、in 运算符

m = 'hello' in var1
print(m)
# 输出：True或者False

17.16、列表加法、乘法

var3 = var1 + var2
# var3 = var1 + var2var2 = var1 * 3
# var2 = var1 + var1 + var1

 17.17、解包

# 一个拥有两件物品的包裹
package = [[1, 2, 3],[4, 5, 6]
]
# 解包，将包裹中的内容赋值给 a, b
a, b = packageprint(a)
# 输出：[1, 2, 3]

十八、元组

元组不可被修改，除了增删改以外，其他的操作和列表一样

var1 = ('hello',)
print(type(var1))
# 输出：<class 'tuple'>

 18.1、zip()

合并两个长度相同的列表，相同位置的元素会被组成一个元组

var1 = ['a','b','c']
var2 = ['hi','my','name']zipped = list(zip(var1, var2))
#zipped = [('a','hi'),('b','my'),('c','name')]for key, value in zipped: #解包print(key)print(value)
# 输出：a hi b my c name

18.2、enumerate()

和zip不同，他显示每个元素的位置

var1 = ['a','b','c']m1 = list(enumerate(var1))
#m1 = [(0,'a'),(1,'b'),(2,'c')]m2 = list(enumerate(var1, 1))
#m2 = [(1,'a'),(2,'b'),(3,'c')]

 18.3、列表和元组互换

varList = list(varTuple)varTuple = tuple(varList )

 十九、range(start, stop, step)

快速生成一个数字序列：

• start是开始默认为0，
• stop停止，但不取stop
• step是步长，默认为1

注意生成后需要转型，如list

list1 = list(range(2, 5, 1))
print(list1)
# 输出：[2, 3, 4]

二十、while循环

whlie 循环条件:循环体

continue：终止本轮循环

break：退出循环

return：退出循环，并返回结果

pass：在语句中只起到占位作用

 二十一、for循环

queue = ['a', 'b', 'c']for q1 in queue:print(q1)

 21.1、常用遍历

# 搭配元组
for i in ('a', 'b', 'c', 'd'):print(i)
# 逐行输出：a b c d# 搭配字符串
for i in 'hello':print(i)
# 逐行输出：h e l l o# 搭配 range() 函数
for i in range(5):print('我爱Python')
# 逐行输出：我爱Python 我爱Python 我爱Python 我爱Python 我爱Python

 21.2、更简洁生成列表

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd_nums = []
for num in nums:# 如果 num 除以 2 余数为 1，表明它是奇数if num % 2 == 1:# 把 num 添加到 odd_nums 中odd_nums.append(num)# 等同nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 从 nums 中挑选出所有奇数，放到新列表 odd_nums 中
odd_nums = [num for num in nums if num % 2 == 1]

二十二、字典

键值对：key:value

dictionary = { 'hello': '你好', 'grape': '葡萄'
} 

22.1、以键key为索引，访问值value

print(dictionary['hello'])
# 输出：你好

22.2、get()，更安全的访问

# 当key存在时
dictionary.get('hello')
# 你好# 当key不存在时
dictionary.get('aaaa')
# None# 可以设置默认值，当key不存在时返回默认值
dictionary.get('aaaa','NO')
# NO

22.3、len()

len(dictionary)
# 2

22.4、in，查找指定元素是否存在在key中

'你好' in dictionary
# False

22.5、简单添加和修改

dictionary['add'] = '添加'dictionary['hello'] = '修改后'

 22.6、字典遍历需要加items()才能解包，而元组不需要，注意和元组区别

staff = {"KD1": "张三","KD2": "李四","KD3": "王五",
}for id, person in staff.items():print(f"{id}：{person}")''' 输出：
KD1：张三
KD2：李四
KD3：王五
'''

 22.7、keys()

staff = {"KD1": "张三","KD2": "李四","KD3": "王五",
}
print(staff.keys())
# 输出：dict_keys(['KD1', 'KD2', 'KD3'])for id in staff.keys():print(f"{id}")'''
KD1
KD2
KD3
'''

22.8、values()

staff = {"KD1": "张三","KD2": "李四","KD3": "王五",
}
print(staff.values())
# 输出：dict_values(['张三', '李四', '王五'])for per in staff.values():print(f"{per}")
'''
张三
李四
王五
'''

 22.9、update()更强大的添加和修改

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}dict1.update(dict2)
print(dict1)  
# 输出: {'a': 1, 'b': 3, 'c': 4}

二十三、列表、元组、字典

23.1、字典中嵌套列表

groups = {'a': ['a1', 'a2', 'a3'],'b': ['b1', 'b2', 'b3'],'c': ['c1', 'c2', 'c3', 'c4'],'d': ['d1', 'd2']
}for group in groups:print(group)
# 输出：a b c dfor group,i in groups.items():print(i)
''' 输出：
['a1', 'a2', 'a3']
['b1', 'b2', 'b3']
['c1', 'c2', 'c3', 'c4']
['d1', 'd2']
'''

23.2、列表中嵌套列表

23.3、列表中嵌套字典

23.4、字典中嵌套字典

23.5、打包与解包

二十四、模块

传统的一个  .py 后缀的文件就是一个模块，每个模块相对独立

 24.1、导入模块

使用：import 模块名

import test
# 此时执行当前文件也会执行test里的代码# 也有from 。。。 import 。。。
from random import randint# 也可以设置别名
import pandas as pd‌‌

24.2、调用模块内的变量和函数

import test# 调用test里的变量
print(test.val1)# 调用test里的函数
test.func1from random import randint
# 直接导入模块中的特定功能，无需模块前缀。
randint(1, 100)import random
letter = random.choice('abcde')
# 随机输出结果
print(letter)
# 输出：'c'
print(letter)
# 输出：'e'

24.3、python常用的内置模块

string	常见字符串操作
re	正则表达式操作
datetime	日期个时间类型
array	高效的数值型数组
random	生成随机数
os.path	文件路径操作
math	数学相关函数与变量
time	时间访问和转换
csv	csv文件的读写
json	json文件的读写

Python3 教程 | 菜鸟教程

 点击上面链接，左边目录都有相关内置模块的使用教学，鼠标滚动下拉就可在目录看到。

二十五、文件操作

# 以只读模式打开桌面xxxx.txt 文件
# open(文件路径, 读取方式)
# 并将返回值赋值给 file，此时 file 是文件类型变量
file = open(r'/Users/jie/Desktop/xxxx.txt', 'r')
# 读取文件中记录的内容
file_content = file.read()
# 文件中内容已经读取完毕，可以关闭文件了
file.close()

路径前加 r 是消除转义等字符带来的歧义

 open(文件路径, 读取方式)

• r：只读
• w：只写，当文件不存在时会报错
• a：追加，当文件不存在时会在此路径下新建文件

 二十六、pip安装第三方库

python安装第三方库可以直接在 命令行 中执行pip相关的指令来实现

26.1、配置镜像

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

26.2、安装第三方库

pip install 库名
# 例：pip install pandas
# 例：pip install pandas==1.1.1

 26.3、其他

# 列出所有已安装的库
pip list# 要查看某个特定库
pip show pandas# 将pandas库升级到最新版本
pip install --upgrade pandas# 获取详细的错误输出
pip install 库名 --verbose

二十七、常见的报错关键字

NameError	名称错误
SyntaxError	语法错误
TypeError	类型错误
ValueError	值错误
IndentationError	缩进错误

 二十八、类（封装）

（对于程序代码层面的）面向对象：把程序看作对象的集合

 28.1、类

# 建议的方式
class 类名:def __init__(self, 参数1, 参数2....):pass

# 不建议的方式
class People:age = 0sex = 'boy'name = 'zhangsan'

 28.2、初始化

 __init__：会在对象被实例化时自动调用

# Java的思路，不建议这样写
class People:age = 0sex = 'boy'name = 'zhangsan'def __init__(self, age, sex, name):self.age = ageself.sex = sexself.name = name# 建议这样
class People:def __init__(self, age = 0, sex = 'boy', name = 'zhangsan'):self.age = ageself.sex = sexself.name = name

28.3、实例化

class People:def __init__(self, age = 0, sex = 'boy', name = 'zhangsan'):self.age = ageself.sex = sexself.name = name# 默认初始化，注意当有__init__函数且形参没有设置默认值时时不能这样写
p1 = People()
print(p1.name)
# 输出：zhangsan# 修改成员变量
p1.name = 'lisi'
print(p1.name)
# 输出：lisi# 自定义初始化，当有__init__函数时能这样写
p1 = People(1, 'boy', 'male')
print(p1.age)
# 输出：1

28.4、isinstance(实例对象, 类)，检查第一个参数是否是第二个参数的实例

class People:def __init__(self, age = 0, sex = 'boy', name = 'zhangsan'):self.age = ageself.sex = sexself.name = namep1 = People()
print(isinstance(p1, People))
# 输出：True

二十九、继承、多态

class People:def __init__(self, age = 0, sex = 'boy', name = 'zhangsan'):self.age = ageself.sex = sexself.name = namedef run(self):print('People run!')# Student继承People
class Student(People):# 不写__init__则默认继承父类# 重写父类方法def run(self):print('Student run!')# 子类新加方法def look(self):passstu=Student()
print(isinstance(stu,People))
# 输出：True

其它，如：子类调用父类方法，子类方法覆盖父类方法等；和Java的思路一样不在赘述

29.1、super

class People:def __init__(self, age=0, sex='boy', name='zhangsan'):self.age = ageself.sex = sexself.name = namedef run(self):print('People run!')# Student继承People
class Student(People):# 不写__init__则默认继承父类# 也可以通过super调用父类构造函数def __init__(self):super().__init__()# 重写父类方法def run(self):print('Student run!')# 也可以通过super调用父类方法super(Student, self).run()# 子类新加方法def look(self):passstu = Student()
print(isinstance(stu, People))
print(stu.name)
stu.run()
# 输出：
# True
# zhangsan
# Student run!
# People run!