Python课程学习笔记上

最新推荐文章于 2022-02-27 17:58:36 发布

VIP文章 tryudamere

最新推荐文章于 2022-02-27 17:58:36 发布

阅读量864

点赞数 1

本文链接：https://blog.csdn.net/tryudamere/article/details/105394512

版权

笔记目录

学前准备
语法基础
函数
文件操作
Python课程学习笔记下

学前准备

Python解释器安装包

下载

官网

安装

Windows：直接安装，勾选Add python3.x to PATH
Linux（ubuntu）：
方法一：使用apt-get工具，在终端键入sudo apt-get install python3.x
方法二：编译源码安装,
1 下载源码：在目标文件夹中打开终端并键入wget-c https://www.python.org/ftp/python/3.8.1/Python- 3.x.tgz(在python官网中复制)![Dowdloads下选择Source code]
2 解压键入：tar -xzvf Python-3.x.tgz
3 配置：终端键入：cd python3.x的解压目录路径，然后键入：sudo ./configure
4 安装编译需要的依赖包：1.终端输入：sudo apt-get install bulid-essential checkinstall，2.sudo apt-get install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev
5 编译：终端键入make
6 安装：终端键入sudo make install完成安装
Linux安装中的下载地址获取方法

Pycharm

下载

官网
Pycharm有专业版（付费使用）和社区版（免费使用），如果所在的学校给学生发放了校园邮箱，可以利用校园邮箱申请教育版Pycharm，免费使用。

常用的快捷键

PEP-8代码规范自动改正：Ctrl+Alt+L
Shift+Enter：换行
Ctrl+/：注释
Ctrl+D：复制一行
Ctrl+Y：删除一行
Ctrl+0：复写代码
选中内容+Tab：退格
Ctrl+F：查找
Ctrl+R：替换
Ctrl+Shift+Numpad-：折叠所有代码
Ctrl+Shift+Numpad+：展开所有代码
Shift+TAB：减少一个缩进

Python程序执行机制

Python程序执行过程

语法基础

注释和中文乱码

1.注释的作用：
帮助我们理解代码逻辑
与别人合作时，减少沟通成本
开发模块时减少他人使用成本
可以临时注释一段代码方便调试

2.注释的类型：

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

1.单行注释：
	1.使用'#' :
		#这是注释
	2.使用' "" '，或者" '' ":
		"这是注释"
 		'这是注释'
2.多行注释:
	使用"  ''' '''  " 
		'''这是一个
多行注释'''
	使用'  "" ""  '
		"""这是一个
多行注释
"""
3 特殊注释
	1.Linux中用于指定解释器
		#!/use/bin/[env] python
	2.pyhon2.x版本中用于处理中文乱码问题
		# encoding=utf-8/_*_coding:utf-8_*_

变量

含义：
	储存数据的容器
特性：
	可以引用某个具体的数值；可以改变这个引用

定义变量的方法

# 方法一：变量名 = 值
num = 1
# 方法二：变量名1, 变量名2 = 值1, 值2
num1, num2 = 1, 2 
# 方法三：变量名1 = 变量名2 = 值
num1 = num2 = 1

变量产生的原因：
	方便维护；节省空间
变量使用注意事项：
	一个变量只能对应一个值
	命名规范：字母，数字（不能位于首位），下划线
	见名知意
	驼峰标识：多个单词组合第二个单词首字母大写
	非关键字：['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']
	区分大小写
变量使用前一定要赋值

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

关键字查询方法：
import keyward
print(keyward.kwlist)

数据类型

定义：
	对程序处理的相关数据进行分类
为什么要区分类型：
	对不同类型的数据分配不同的储存空间
	根据数据类型的特征，做相应的数据处理
数据类型：
	Numbers（数值）、Bool（布尔）、String（字符串）、List（列表）、Set（集合）、Tuple（元组）、
	Dictory（字典）、NoneType（空类型）

数据转化：

函数	说明
int(x,[,base])	将x转化成一个整数（向下取整）
float(x)	将x转化成一个浮点数
str(x)	将x转化成一个字符串
repr(x)	将x转化成一个表达式字符串
chr(x)	将x转化成一个对应的ASCII字符
unicoed(x)	将x转化成一个Unicode字符
ord(x)	将字符x转化成对应的ASCII整数值
hex(x)	将x转化成一个十六进制的字符串
oct(x)	将x转化成一个对应的八进制字符串
eval(str)	计算字符串中的有效表达式，并返回对象
tuple(s)	将序列s转换成一个元组
list(s)	将序列s转化成一个列表

动态类型与静态类型：
	静态类型：数值类型是编译的时候确定的，后期无法修改（c语言）
	静态类型：数值类型是运行时进行判定的，可以动态修改（python）
强类型与弱类型：
	弱类型：数值类型比较弱势，不同的环境下，很容易·改变
	强类型：数值类型比较强势，不会轻易随环境的变化而变化

查看数据类型的方法：
print(type('想要查看的数据'))

运算符

数值运算符

符号	含义
+	加法运算符
-	减法运算符
*	乘法运算符
**	幂运算符
/	除法运算符（结果为浮点数）
//	整除运算符（结果为整数，向下取整）
%	求模运算符（求余运算符）
=	赋值运算符
注意	除法除数不能为零，算术优先顺序和数学一致

复合运算符

符号	等价式子
公式	x op y ==> x = x op y （op为二次运算符）
+=	x += y ==> x = x + y
-=	x -= y ==> x = x - y
*=	x = y ==> x = x y
/=	x /= y ==> x = x / y
%=	x %= y ==> x = x % y
//=	x //= y ==> x = x // y
**=	x = y ==> x =x y

比较运算符

符号	含义
<	小于
>	大于
!= / <>（仅限python2.x）	不等于
<=	小于等于
>=	大于等于
==	等于
is	判断唯一标识是否相等(id(a) is id(b))
a < b <c	链式比较运算符

数据唯一标识获得方法：id(xxx)

逻辑运算符


not	非，真取假，假取真(not False >>>True
or	或，一真全真
and	与，一假全假

注意：
	1.非布尔类型的值，假如作为真假来判断，一般非零即真，非空即真
    2.判断顺序从左至右,返回决定的值
    3.整个逻辑表达式返回的结果不一定只是False或者True
    	and:1、print(5 and True)
    	
    	       # True
    	       
    	    2、print(True and 5)
    	      
    	       # 5
    	       
    	    3、print(0 and True)
    	       
    	       # 0
    	       
    	    4、print(True and 0)
    	       
    	       # 0
    	       
        or: 1、print( 5 or True)
               
               # 5
                
            2、print(True or 5)
               # True
            3、print(5 or False)
              
               # 5
            
            4、print(False or 5)
			
			   # 5

输入输出和格式符

输入和输出

程序数据的来源：
	1.程序内部已有的
	2.从文件读取的
	3.从网络服务器获取的
	4.用户输入的
已经处理好的数据如何处理：
	1.写回文件保存
	2.返回到网络服务器保存
	3.打印到控制台，通过一些界面展示给用户
输入函数：
	python2.x：
		raw_input()
			将用户输入的内容当作字符串传递给变量
		input() ==> raw_input(eval())
			将用户输入的内容当作代码进行执行
	python3.x:
		input()
			功能等价于python2.x中的raw_input()

输出：
python2.x

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

#python2.x输出，主要使用print语句

#1.格式化输出
#使用".format()"函数
print "我是{0}，今年{1}岁".format(xxx,17)

# 我是xxx，今年17岁

#使用字符串格式化
#
print "我是%s，今年%d岁"%(xxx,17)

# 我是xxx，今年17岁

#2.输出到文件中
#没有文件将会自动创建
#
File = open(book.txt,"w")
print >>File,"xxxx"

#输出自动不换行
#输出目标末尾加上","
print '1',
print '2',
print '3'

# 1 2 3	

#输出各值使用分隔符分割
#1.手动添加，2.使用join()函数
print '+'join.(["1","2","3"])

# 1+2+3

python3.x

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# _*_ coding:utf-8 _*_
#python3.x输出，主要使用print(values,sep,end,file,flush)函数
#values:需要输出的值，sep:分割符，值与值之间添加特定的分隔符，end:输出结束后，以特定的符号结束，默认"/n"，
#file: 输出的目标，默认是控制台，flush:直接输出，值为布尔类型

#格式化输出同python2.x

#输出到文件中
F = open(book.txt, "w")
print("xxxx", file = F)
#默认情况，输出到控制台
import sys
print('xxx', file = sys.stdout) 

# xxx

#输出不换行
print('xxx', end = '')

# xxx

#输出各值使用分隔符分割
print("a", "b", "c", sep = '^*^')

# a^*^b^*^c

#flush参数说明
#在以下情况，程序将等待5s后才会打印xxxx
import time
print('xxxx',end = '')
time.sleep(5)
#想要先打印xxxx，在等待5s
import time 
print('xxxx',end = '',flush = True)
time.sleep(5)
#产生原因：python输出时，先将要输出的内容转存到缓冲器当中。默认情况下，print()函数以'/n'结尾，自动换行，
#程序会等待print语句执行后才继续前进。去掉'/n'后，函数不会自动换行，会将下一句与print()识别为同一句一并执
#行，使用flush = True可以强制先执行print(),再执行后面的语句。

格式符

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

python占位格式符
# %[(name)[flags][width][.precision]typecode
#[]是可以省略的选项

#1.name为数据设置标识，制定的名称（key），查找对应的值，并格式化到字符串中
name = 'Jack'
score = 90
print("%(N)s的分数是%(S)d"%({
   'N':name, 'S':score}))

# Jack的分数是90

#2.width，表示占用的宽度
hour, minute = 6, 4
print("当前时间是：%(H)2d:%(M)2d"%({
   "H":hour,"M":minute}))

# 当前时间是： 6: 4

#3.flags设置数据格式
#空格，向右对齐
hour, min = 6, 4
print("当前时间是：%(H) 5d:%(M) 5d"%({
   "H":hour,"M":min}))

# 当前时间是：    6:    4

#-，向左对齐
hour, min = 6, 4
print("当前时间是：%(H)-5d:%(M)-5d"%({
   "H":hour,"M":min}))

# 当前时间是：6    :4    

#0，表示用0填充
hour, min = 6, 4
print("当前时间是：%(H)02d:%(M)02d"%({
   "H":hour,"M":min}))

# 当前时间是：06:04

#4..precision，申明保留几位小数（四舍五入）
num = 1.296764
print("请保留小数点后四位：%.4f"%num)

# 请保留小数点后四位：1.2968

typecode

类型	符号	含义
数值	i/d	将整数、浮点数转化成十进制数
数值	o	将整数转化成八进制数
数值	x	将整数转化成十六进制数
数值	e	将整数、浮点数转化成科学计数法（小写e）
数值	E	将整数、浮点数转化成科学计数法（大写E）
数值	f	将整数、浮点数转化成浮点数（默认保留小数点后六位
数值	F	同f
数值	g	自动调整将整数、浮点数转化成浮点数或者科学计数法表示（通常超过六位用科学计数法）
数值	G	同g
字符串	s	获取传入对象的_str_方法的返回值
字符串	r	获取传入对象的_repr_方法的返回值
字符串	c	将数字转化成其对应的Unicode编码，十进制范围为0<=i<=1114111
特殊	%	当字符串中存在格式换标志时，需要用%%表示一个百分号
注意		Python中百分号格式化不存在自动将整数转化成二进制表示的方式，即不存在print(’%b’%121)

单分支和多分支（if语句）

python程序执行顺序

	大体上从上至下
	分支：进入不同的分支
	循环：多次执行相同的代码

单分支

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

 # if 条件:
 #   条件满足时，执行语句
age = 19
if age >= 18:
    print('你已成年，可以上网')

# 你已成年，可以上网

双分支

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

#if 条件:
#   条件满足时执行的语句
#else：
#   条件不满足时执行的语句
age = 11
if age >= 18:
    print("可以上网")
else:
    print("未成年，不能上网，赶紧回家吃饭")

# 未成年，不能上网，赶紧回家吃饭

if嵌套

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# if嵌套
# if 条件:
#     满足条件时执行的语句
# else:
#     不满足条件时需要执行的语句
#     if:
#         满足条件时执行的语句
#     else:
#         不满足条件时执行的语句
#         if:
#             满足条件时需要执行的语句
#         else:
#             不满足条件时执行的语句
Score = 98
if 85 <= Score <= 100:
    print('优秀')
else:
    if 70 <= Score < 85:
        print('良好')
    else:
        if 60 <= Score < 70:
            print('合格')
        else:
            print('不及格')
          
# 优秀

if嵌套的优略：减少对冗余代码的执行，提升代码的性能。但是难以阅读

if多分支

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# if多分支,elif部分根据需要可以重复执行
# if 条件:
#     满足条件时执行的语句
# elif:
#     条件满足时执行的语句
# else:
#     条件满足时执行的语句
Score = 98
if 85 <= Score <= 100:
    print('优秀')
elif 70 <= Score < 85:
    print('良好')
elif 60 <= Score < 70:
    print('合格')
else:
    print('不及格')

# 优秀

if注意事项

1.强制缩进，一般使用TAB
2.区分代码块隶属于那个分支；区分else与那个if匹配（主要用于if嵌套）
3.python中没有类似与其他语言的switch...case语法

循环

while循环

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

#语法
#while 条件:
#	满足条件时执行的代码
num = 1
while num < 3:
	num += 1
print(num)

# 3

# 计算1-10的和
num, result = 0, 0
while num < 10:
	num += 1
	result += num
print(result)

# 55

while循环与else连用：

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 语法
# while 条件:
#    满足条件时执行的代码
# else:
# 	 因条件不满足而结束循环时执行的代码
num = 0
while num < 10:
	num += 1
else:
	print(num)

# 10

# 如果while循环因为break打断，那么后续的else代码块将不会被执行
num = 0
while num < 10:
    num += 1
    print(num)
    if num == 3:
        break
else:
    print('程序结束')

# 1
# 2
# 3

注意事项：
	注意循环结束条件，防止死循环
	python语言中，没有其他语言中的do...while循环

for循环

# for xx in xxx:
#     循环的代码块
# xxx一般是集合；xx是从集合里面取出的一个元素，在循环体中可以直接使用xx的值
# 当集合中的元素被遍历完后，循环结束
notice = '富强、民主、和谐'
for i in notice:
    print(i, end='+')
   
# 富+强+、+民+主+、+和+谐+

for循环与else连用：方法与while与else连用一致。

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# python循环打断：break与continue
# 当满足break的条件时，打断本次循环并结束整个循环
# 当满足continue的条件时，跳过当前循环，继续下一个循环

# break
for i in range(5):
    if i == 2 or i == 3:
        break
    print(i, end=',')

# 0,1,

# continue
for i in range(5):
    if i == 2 or i == 3:
        continue
    print(i, end=',')

# 0,1,4,

pass语句：
	含义：是空语句，不做任何事情，一般用作占位符
	作用：为了保持程序的完整性

python常用数据类型操作

数值

表现形式

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3
# 表现形式：python3.x中的整型可以自动的调整大小，相当于python2.x中的long类型；数值区分正负
# 整数(int)
#   二进制，0b/0B，只包含0，1
num1, num2 = 0b01, 0B01
print(num1, num2)

# 1 1

#   八进制，0o/0O，只包含0-7
num1, num2 = 0o01234567, 0O01234567
print(num1, num2)

# 342391 342391

#   十六进制，0x/0X，只包含0-15，10-15使用a、b、c、d、e、f表示
num1, num2 = 0x0123456789abcdef, 0X0123456789abcdef
print(num1, num2)

# 81985529216486895 81985529216486895

# 浮点数(float)，包含整数和小数部分，可以用科学计数法表示
num = 1.234e2
print(num)

# 123.4

# 复数(complex)，包含实部和虚部
#   num = a + bj
num = 1 + 2j
print(num)

# (1+2j)

#   num = complex(a, b)
num = complex(1,2)
print(num)

# (1+2j)

进制转换

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 进制
# 概念：逢x进1即x进制

# 进制转换

# 其他进制转化成十进制

# n位x进制数=>十进制：an*x**(n-1)+a(n-1)*x**(n-2)···a1*x**0
num = '0b1111111'
# 获取数字长度，以及储存结果
Len = len(num) - 2
Ten = 0
# 通过循环满足转换式子
for i in range(Len):
    i = i + 1
    an = eval(num[-i])
    Ten = Ten + an * 2 ** (i - 1)
# 打印两个结果查看是否相等
print(Ten == eval(num))

# True
# num转化成十进制数后是：127

# 十进制转换成其他进制

# 方法：除K取余法
#       函数法：二进制bin()、八进制oct()、十六进制hex()

# 除K取余法
num = 123456789
BNum = bin(num)
# 设置余数
K = 2
result = ''
# 建立循环进行除K
while True:
    result = str(num % K) + result
# 设置循环结束条件
    if num // K == 0:
        result = '0b' + result
        print('num转化成二进制数是：{}'.format(result))
# 验证方法是否正确
        print(result == BNum)
        break
    num = num // K

# num转化成二进制数是：0b111010110111100110100010101
# True

# 函数法
# 二进制，bin()函数
num = 1548421
print('num的二进制数是：{}'.format(bin(num)))

# num的二进制数是：0b101111010000010000101

# 八进制，oct()函数
print('num的八进制数是：{}'.format(oct(num)))

# num的八进制数是：0o5720205

# 十六进制数，hex()函数
print('num的十六进制数是：{}'.format(hex(num)))

# num的十六进制数是：0x17a085

# 二进制转化成八进制：1.先转换成十进制，再转换成八进制；2.使用函数；3.整合三位为一位
num = 0b1001011
# num1 = 001 001 011
# 0b001 = 0o1
# 0b011 = 0o3
# num = 0o113
num2 = oct(num)
print(num2, num2 == '0o113')

# 0o113 True

# 二进制数转化成十六进制数：1.先转换成十进制，再转换成十六进制；2.使用函数；3.整合四位为一位
num = 0b10010001010
# num1 = 0100 1000 1010
# ob0100 = 0x4
# 0b1000 = 0x8
# 0b1010 = 0xa
num2 = hex(num)
print(num2, num2 == "0x48a")

# 0x48a True

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 常用操作

# 部分函数使用前需要导入

# 方法一：
# import 模块名
# 模块名.函数名(参数)
import time

print(time.localtime())

# 方法二：
# form 模块名 import 函数
# 函数(参数)
from datetime import datetime

print(datetime.now())

# 方法三：
# import 模块名 as 名称
# 名称.函数(参数)
import time as T

print(T.localtime())

# 方法四：
# from 模块名 import 函数 as 名称
# 名称(参数)
from datetime import datetime as Dt

print(Dt.now())

# 方法五：
# import 模块名, 模块名, 模块名, 模块名(适用于导入多个模块)
import time, datetime

print(time.localtime(), datetime.datetime.now())


# 常用的数学函数

# 求绝对值， abs(num)
num = - 19
print(abs(num))

# 19

# 求最大值， max(num1, num2, num3, ······)
print(max(1, 5, 6, 3, 20))

# 20

# 求最小值， min(num1, num2, num3, ······)
print(min(10, 39, 42, 1, 12))

# 1

# 四舍五入， round(x[, n])，n是保留的位数，默认为0
num = 22/7
print(round(num, 3))

# 3.143

# 幂运算， pow(x, y)， x是底数，y是指数
x, y = 2, 4
print(pow(x, y))

# 16

# math模块函数
import math

num = 22/7
# ceil(), 向上取整
print(math.ceil(num))

# 4

# floor(), 向下取整
print(math.floor(num))

# 3

# sqrt(), 开方运算
print(math.sqrt(16))

# 4

# log(x, base), 以base为底数，求x的对数
print(math.log(10000, 100))

# 2

# math模块三角函数
import math

# 常量Π的表示
print(math.pi)

# 3.141592653589793

# degrees(x), 弧度转化为角度
degree1 = 1 / 6 * math.pi
print(math.degrees(degree1))

# 29.999999999999996

# radians(x), 角度转化为弧度
degree2 = 60
print(math.radians(degree2))

# 1.0471975511965976

# sin(x), 正弦; cos(x), 余弦: tan(x), 正切; asin(x), 反正弦; acos(x), 反余弦; atan(x), 反正切.
# x传递的是弧度
print(math.sin(degree1), math.cos(degree1), math.tan(degree1), math.asin(degree1), math.acos(degree1), math.atan(degree1))

# 0.49999999999999994 0.8660254037844387 0.5773502691896257 0.5510695830994463 1.0197267436954502 0.48234790710102493

# random随机函数模块
import random

# random(), 返回一个[0, 1)之间的小数
print(random.random())

# 0.8519072713974626

# choice(seq), 从序列seq中随机挑选一个数
seq = [5, 2, 6, 1, 7, 8, 4]
print(random.choice(seq))

# 2

# uniform(x, y), 返回一个[x, y]之间的随机小数
print(random.uniform(1, 9))

# 3.5754090587362395

# randint(x, y), 返回一个[x, y]之间的随机整数
print(random.randint(1, 9))

# 5

# randrange(start, stop = None, step = 1), 随机返回一个位于[start, end)之间的，步长为step的整数
print(random.randrange(1, 9, 3))

# 4

布尔(bool)

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 布尔类型
# 值：True, False

# 是int类型的子类，sisubclass()判断前一个变量是否是后一个变量的子类
print(issubclass(bool, int))

# True

# 当作int类型参与运算
result1 = True + 1
result2 = False + 1
print(result1, result2)

# 2 1

# 用于比较表达式的运算结果
# 用于if判定条件和while循环条件

字符串（str）

概念、形式

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 概念：由单个字符组成的集合

# 补充：转义符：'\'，通过转换某个指定的字符，使它具有特殊的含义
# 常见转义符：
# \ 位于行尾时   续航符
Str = '天道' \
      '酬勤'
print(Str)

# 天道酬勤

# \'    单引号    \"    双引号
Str1 = "神曰：\"不可说\"！"
Str2 = '神曰：\'不可说\'！'

# \n    换行
print('Do\nWhat\nYou\nLove')

# Do
# What
# You
# Love

# \t    制表符
print('2\t4\t8')

# 2  4	8

# 字符串形式
# 非原始字符串，使用单引号、双引号、三个单引号、三个双引号
Str3 = '这是一个\n字符串'
Str4 = "这是一个\n字符串"
Str5 = '''这是一\
个多行
字符串\n'''
Str6 = """这是一\
个多行
字符串\n"""
print(Str3, Str4, Str5, Str6)

# 这是一个
# 字符串 这是一个
# 字符串 这是一个多行
# 字符串
#  这是一个多行
# 字符串

# 原始字符串，使用单引号、双引号、三个单引号、三个双引号
Str7 = r'这是一个字符串'
Str8 = r"这是一个\n字符串"
Str9 = r'''这是一\
个多行
字符串'''
Str0 = r"""这是一\
个多行
字符串"""
print(Str7, Str8, Str9, Str0)

# 这是一个字符串 这是一个\n字符串 这是一\
# 个多行
# 字符串 这是一\
# 个多行
# 字符串

# 跨行：使用换行符\，或者使用小括号
name1 = ('天道'
         '酬勤')
name2 = "天道" \
        '酬勤'
print(name1, name2)

# 天道酬勤 天道酬勤

字符串操作

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 字符串的一般操作
# 字符串的拼接
# str1 + str2
print('天道' + "酬勤")

# 天道酬勤

# str1str2
print('天道'"酬勤")

# 天道酬勤

# 'xxx%sxx'%''或者format()
print('天道%s' % "酬勤")
print('天道{}'.format("酬勤"))

# 天道酬勤

# 字符串乘法
print('天道酬勤\t' * 3)

# 天道酬勤	天道酬勤	天道酬勤

# 字符串的切片操作
# 概念：获取某一个字符串中的某一段
# 获取某个字符，str[下标], 下表有两种，顺序从0开始，倒序从-1开始
Str = 'abcdefgh'
print(Str[2], Str[-1])

# c h

# 获取字符串的一个片段
# str[start:end:k], 截取范围[start, end), start默认值是0，end默认值是len(str)，k步长的默认值是1
# 当k > 0时，截取顺序从左至右，当k < 0时，截取顺序从右至左
# 不能从头部跳到尾部，反之亦然；即不能str[0:len(str):-1] 或者 str[-len(str):-1:1]
Str = 'abcdefg'
print(Str[0:4:2])

# ac

# 反转字符串str[::-1]
print(Str[::-1])

# gfedcba

字符串函数操作

查找计算

# _*_ coding:utf-8 _*_
# !/usr/bin/env python3

# 字符串的函数操作
# 内建函数可直接使用，对象方法使用方法为：对象.方法(参数)
# 查找计算

# len()函数（内建）
# 作用：计算字符串长度
# 语法：len(str)
# 参数：str字符串
# 返回值：字符串长度，int类型
# 注意：转义符整个算一个字符
Str = 'Do what you love'
print(type(len(Str)), len(Str))
Str1 = 'Do what\n you love'
print(len(Str1))

# <class 'int'> 16
# 17

# find()函数（对象方法）
# 作用：查找子串索引位置
# 语法：str.find(sub, start=0, end=len(str))
# 参数：sub:需要检索的子串，start：检索的起始位置，默认为0，end：检索的结束位置，默认为len(str)
# 返回值：
#         找到了：指定索引，int类型
#         没找到：-1
# 注意：
#       查找范围{start, end)
#       从左至右找，找到后立即停止
print(type(Str.find('o', 4)), Str.find('o', 4))

# <class 'int'> 9

# rfind()函数（对象方法）
# 作用：同find()
# 语法：同find()
# 参数：同find()
# 返回值：同find()
# 注意：
#      同find()
#      区别：从右至左查找
print(type(Str.rfind('o', 4, 13)), Str.rfind('o', 4, 17))

# <class 'int'> 13

# index()函数（对象方法）
# 作用：获取子串索引位置
# 语法：str.index(sub, start=0, end=len(str))
# 参数：sub：需要检索的字符串，start：检索起始的位置，end：检索结束的位置
# 返回值：
#        找到了：指定索引，int类型
#        没找到：异常：ValueError: substring not found
# 注意：
#      查找范围：[start, end)
#      从左至右查找，找到后立即停止
print(type(Str.index('t', 4, 7)), Str.index('t', 4, 7))

# <class 'int'> 6

# rindex()函数（对象方法）
# 作用：同index()
# 语法：同index()
# 参数：同index()
# 返回值：同index()
# 注意：
#      同index()
#      区别：从右至左查找
print

最低0.47元/天解锁文章

tryudamere

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Python课程学习笔记上

笔记目录学前准备Python解释器安装包下载安装Pycharm下载常用的快捷键Python程序执行机制语法基础注释和中文乱码变量数据类型运算符数值运算符复合运算符比较运算符逻辑运算符输入输出和格式符输入和输出格式符单分支和多分支（if语句）python程序执行顺序单分支双分支if嵌套if多分支if注意事项循环while循环for循环python常用数据类型操作数值布尔(bool)字符串（str）列...
复制链接

扫一扫