（一）、Python IDLE常用快捷键
（二）、Python基础语法
- 1、基本类型之字符串string
  - ①转义字符
出错
结果
2、基本类型之其他
3、基本运算符
4、循环与选择
- ①选择
- ②循环
  - while结构：
  - for结构：
5、断言
6、类型判断
- ①type()
- ②isinstance（）
（三）、Python 常用的的 BIF
- 1、print
- 2、input

（一）、Python IDLE常用快捷键

（二）、Python基础语法

1、基本类型之字符串string

①转义字符

在字符串中，需要打出 ‘ 单引号，” 双引号，\ 斜杠等等，需要用到转义字符\

示例：

str = ‘你好’’

出错
str = ‘你好\’’ print(str)

结果
你好’

常用的转义字符

换行：\n
回车：\r
水平制表符：\t
退格：\b
②原始字符串
原始字符串是Python中一类比较特殊的字符串，以大写字母R或者小写字母r开始。在原始字符串中，字符“\” 不再表示转义字符的含义。（一般用来写文件路径和正则表达式）

例子：

import ospath = r”F:\program” os.listdir(path) [‘compress’, ‘day02’, ‘day10’] path1 = R”F:\program” os.listdir(path1) [‘compress’, ‘day02’, ‘day10’]

当 r 或者 R 前缀存在的时候，在反斜杠后面的字符保持不变，并且反斜杠本身会保留在字符串中。
所以任何在反斜杠后面的字符都是原始字符串的一部分。这样一来：

r’abc\d’ 由 a, b, c, \, d 组成
r’abc\’d’ 由 a, b, c, \, ‘, d 组成
r’abc\’’ 由 a, b, c, \, ‘ 组成
那么，重点来了：

r’abc\’ 由 a, b, c, \, ‘ 组成，但是现在没有结束字符串的引号了！
所以原始字符串无法以单个的（奇数个的）反斜杠结尾。
[

](https://blog.csdn.net/jpch89/article/details/83479625)
解决方案：
Ⅰ不在原始字符串后面写单个反斜杠，而是采用拼接的方式用普通字符串加上反斜杠。

test = r’测试’’\‘>>> print(test) 测试\

Ⅱ在原始字符串后面写两个反斜杠，然后采用切片操作切除最后一个反斜杠。

test = r’测试\‘[:-1]>>> print(test) 测试\

Ⅲ不使用原始字符串，直接使用普通字符串。

test = ‘测试\‘>>> print(test) 测试\

③多行字符串

连续三个单引号或三个双引号，可以帮助我们创建多行字符串。例如：

>>> resume = ‘’’ name=”gaoqi” company=”sxt” age=18 lover=”Tom”‘’’ >>> print(resume) name=”gaoqi” company=”sxt” age=18 lover=”Tom”

④字符串操做

字符串之间的转换：

使用内置函数 ord()可以把字符转换成对应的 Unicode 码；
使用内置函数 chr()可以把十进制数字转换成对应的字符。
例子：

>>> ord(‘A’) 65 >>> ord(‘高’) 39640 >>> chr(66) ‘B’ >>> ord(‘淇’) 28103

多字节与宽字节解释：

//外国一个字节对应一个字节多字节 //中国一个字节对应多个字节宽字节 Unicode utf8 对应三个字节 GBK 对应两个字节 // “aaaa” //这样的就是多字节 Ascll码属于Unicode 有一个Ascll码表可以查询对应关系

计算字符串长度：

len()用于计算字符串含有多少字符。

>>> d = ‘abc 尚学堂’ >>> len(d) 6

字符串拼接：

1.可以使用+将多个字符串拼接起来。
例如：

’aa’+ ’bb’ ==>’aabb’。

(1) 如果+两边都是字符串，则拼接。
(2) 如果+两边都是数字，则加法运算。
(3) 如果+两边类型不同，则抛出异常。

2.可以将多个字面字符串直接放到一起实现拼接。
例如：

’aa’’bb’==>’aabb’

[

](https://blog.csdn.net/weixin_43158056/article/details/92798114)
3.join函数
使用字符串拼接符+，会生成新的字符串对象，因此不推荐使用+来拼接字符串。推荐
使用 join 函数，因为 join 函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。

import time time01 = time.time() #起始时刻 a = “” for i in range(1000000):

a += “sxt” time02 = time.time() #终止时刻 print(“运算时间：”+str(time02-time01)) time03 = time.time() #起始时刻 li = [] for i in range(1000000): li.append(“sxt”) a = “”.join(li) time04 = time.time() #终止时刻 print(“运算时间：”+str(time04-time03))

字符串复制：

使用*可以实现字符串复制。

>>> a = ‘Sxt’*3 >>> a ‘SxtSxtSxt’

其他类型转换字符串：

str()可以帮助我们将其他数据类型转换为字符串。

str(5.20) ==> ‘5.20’ str(3.14e2)==>’314.0’ str(True) ==> ‘True’

当我们调用 print()函数时，解释器自动调用了 str()将非字符串的对象转成了字符串。

使用[]提取字符：

字符串的本质就是字符序列，我们可以通过在字符串后面添加[]，在[]里面指定偏移量，可以提取该位置的单个字符。

正向搜索：最左侧第一个字符，偏移量是 0，第二个偏移量是 1，以此类推。直到 len(str)-1

为止。

反向搜索：最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2，以此类推，直到-len(str)

为止。
[

](https://blog.csdn.net/weixin_43158056/article/details/92798114)

>>> a = ‘abcdefghijklmnopqrstuvwxyz’ >>> a ‘abcdefghijklmnopqrstuvwxyz’ >>> a[0] ‘a’ >>> a[3] ‘d’ >>> a[26-1] ‘z’ >>> a[-1]

‘z’ >>> a[-26] ‘a’ >>> a[-30] Traceback (most recent call last): File ““, line 1, in a[-30] IndexError: string index out of range

replace()实现字符串替换：

字符串不可改变。但是，我们确实有时候需要替换某些字符。这时，只能通过创建新的字符串来实现。

>>> a = ‘abcdefghijklmnopqrstuvwxyz’ >>> a ‘abcdefghijklmnopqrstuvwxyz’ >>> a = a.replace(‘c’,’高’) ‘ab 高 defghijklmnopqrstuvwxyz’

切片操作：

切片 slice 操作可以让我们快速的提取子字符串。
标准格式为：

[起始偏移量 start：终止偏移量 end：步长 step]

切片操作时，起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围，也不会报错。起始偏移量小于 0 则会当做 0，终止偏移量大于“长度-1”会被当成-1。
例如：

“abcdefg”[3:50] ‘defg’

字符串驻留机制：

仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串驻留池中。Python 支持字符串驻留机制，对于符合标识符规则的字符串（仅包含下划线（_）、字母和数字）会启用字符串驻留机制驻留机制。

示例：

>>> a = “abd_33” >>> b = “abd_33” >>> a is b True >>> c = “dd#” >>> d = “dd#” >>> c is d False >>> str1 = “aa” >>> str2 = “bb” >>> str1+str2 is “aabb” False >>> str1+str2 == “aabb” True

字符串比较：

我们可以直接使用==,!=对字符串进行比较，是否含有相同的字符。
我们使用 is / not is，判断两个对象是否同一个对象。比较的是对象的地址，即 id(obj1)是否和 id(obj2)相等。

字符串成员操做：

in /not in 关键字，判断某个字符(子字符串)是否存在于字符串中。

常用的字符串查找方法：

去除首尾信息：

我们可以通过 strip()去除字符串首尾指定信息。通过 lstrip()去除字符串左边指定信息，rstrip()去除字符串右边指定信息。

>>> “sxt“.strip(“*”) ‘sxt’ >>> “sxt“.lstrip(“*”) ‘sxt*’ >>> “sxt“.rstrip(“*”) ‘sx*t’ >>> “ sxt “.strip() ‘sxt’

大小写转换：

编程中关于字符串大小写转换的情况，经常遇到。
我们将相关方法汇总到这里。为了方便学习，先设定一个测试变量：a = “gaoqi love programming, loveSXT”

格式排版：

center()、ljust()、rjust()这三个函数用于对字符串实现排版。示例如下：

>>> a=”SXT” >>> a.center(10,”*”) ‘*SXT**’ >>> a.center(10) ‘ SXT ‘ >>> a.ljust(10,”*”) ‘SXT*‘**

其他：

isalnum() 是否为字母或数字
isalpha() 检测字符串是否只由字母组成(含汉字)。
isdigit() 检测字符串是否只由数字组成。
isspace() 检测是否为空白符
isupper() 是否为大写字母
islower() 是否为小写字母

例子：

>>> “sxt100”.isalnum()True >>> “sxt 尚学堂”.isalpha() True >>> “234.3”.isdigit() False >>> “23423”.isdigit() True >>> “aB”.isupper() False >>> “A”.isupper() True >>> “\t\n”.isspace() True

格式化字符串：

格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。
我们通过示例进行格式化的学习。

示例：

>>> a = “名字是:{0},年龄是：{1}”.format(“高淇”,18) ‘名字是:高淇,年龄是：18’
>>> b = “名字是：{0}，年龄是{1}。{0}是个好小伙”.format(“高淇”,18) ‘名字是：高淇，年龄是 18。高淇是个好小伙’

填充与对齐：

填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

示例：

>>> “{:*>8}”.format(“245”) ‘*245’ >>> “我是{0},我喜欢数字{1:^8}”.format(“高淇”,”666”) ‘我是高淇,我喜欢数字666‘**

数字格式化

浮点数通过 f，整数通过 d 进行需要的格式化。案例如下：

>>> a = “我是{0}，我的存款有{1:.2f}” >>> a.format(“高淇”,3888.234342) ‘我是高淇，我的存款有 3888.23’

字符串的内置函数

2、基本类型之其他

①整型int
②浮点型float

整型，浮点型，字符串之间的转换

str() 转换为字符串
int() 转换为整型，浮点型转换为整形，直接去掉小数点后面的东西，字符串转整型，字符串中只能含有数字
float() 转换为浮点型，字符串转浮点型，字符串中只能含有数字

e记法

就是科学计数法,形式如下

a = b * 10^n a = ben #e就代表10的n次方，n要带上正负号

③布尔型bool
只有两个值：True,False
True == 1
False ==0

bool()将其他类型值转换为布尔类型

空字符串，空列表，0，None —— False 其余 —— True

④复数

在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a = b + cj

内置函数：

a.real 返回复数的实部 a.imag 返回复数的虚部 a.conjugat() 返回改复数的共轭复数

用于创建一个复数，或将一个数字或字符串转换为复数形式：

complex（real,imag）

其中，real可以为int、long、float或字符串类型；而image只能为int、long、或float类型。
注意：如果第一个参数为字符串，第二个参数必须省略，若第一个参数为其他类型，则第二个参数可以选择。

例子：

>>> 1 + 1j (1+1j)
>>> complex(1) #数字 (1+0j)
>>> complex(1,2) (1+2j)
>>> complex(“1”) #当做字符串处理 (1+0j)
complex(“1 + 2j”) #会出错，+号两边不能有空格，否则会报错 >>> complex(“1+2.0j”) (1+2j)
第一个参数为字符串，还添加第二个参数时会报错：>>> complex(“x”,15) TypeError: complex() can’t take second arg if first is a string

[

](https://blog.csdn.net/weixin_35825858/article/details/113974562)

3、基本运算符

①算数运算符

+ 加
- 减
* 乘
** 幂运算（ab = a^b）
/ 除
// 地板除法（结果只会给出整型！）**

②比较运算符

> 大于
< 小于
== 等于
!= 不等于
>= 大于等于
<= 小于等于

③逻辑运算符

and 和运算（左右都为真，才为真）
or 或运算（左右只用一个为真，既为真）
not 非运算（条件为假，则为真）

④运算符优先级！

**（幂运算左边的单目运算符【+，-】小于幂运算，右边的大于幂运算）>乘除>加减>比较>逻辑

4、循环与选择

①选择

结构：

if 条件： …… …… elif 条件： …… …… else： …… ……

注意缩进！！

②循环

while结构：

while 条件： …… ……

for结构：

for i in range(a,b): …… ……

range( )是python中产生一个数的集合工具，基本结构为range(start,stop,step)，即产生从start数开始，以step为步长，至stop数结束的数字集合，不包含stop数，start可以省略，默认为0，step也可，默认值为1

for循环遍历range（）产生的集合，并把集合中的每一个元素赋值给i，然后输出每一个i值
这里可以用continue和break做一个for循环测试

反向遍历：
当step值为负数时，为反向遍历，此时的起始值为反向便利的开始值！结束值为终点值-1。

break:直接跳出循环，不再执其后的语句以及不在进行循环；continue:跳出本次循环，不执行其后语句但继续从头执行循环；**

注意缩进！！

5、断言

assert(条件) 当条件为假时，结束程序并抛出异常

常用于检测程序运行时

6、类型判断

①type()

当将单个参数传递给type（）函数时，它将返回对象的类型。它的值与object . class实例变量相同。

type(object)

当传递三个参数时，它将返回一个新的类型对象。它用于动态动态创建类。

“名称”字符串成为类名称。与类的name属性相同。
“基”元组指定基类。与类的bases属性相同。
“ dict”字典用于创建类主体。与类的dict属性相同。
type(name, bases, dict)

②isinstance（）

语法：

isinstance(object, classinfo)

例子：

a = 2isinstance(a,int) # 结果返回 True

isinstance(a,str) # 结果返回 False

isinstance(a,(str,int,list)) # 是元组中的一个，结果返回 True

与type（）区别
在继承上的区别：

isinstance() 会认为子类是一种父类类型，考虑继承关系。
type() 不会认为子类是一种父类类型，不考虑继承关系。

（三）、Python 常用的的 BIF

1、print

print() 方法用于打印输出，是python中最常见的一个函数。
语法如下：

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout)

参数：
objects —表示输出的对象。输出多个对象时，需要用 , （逗号）分隔。
sep — 用来间隔多个对象。
end — 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符。
file — 要写入的文件对象。

①常量输出

示例：

print(1) #数值类型可以直接输出 ‘’’ 运行结果如下 1 ‘’’

print(“Hello World”) #字符串类型可以直接输出

‘’’ 运行结果如下： Hello World ‘’’

a=1 b=”Hello World” print(a, b) #可以一次输出多个对象，对象之间用逗号分隔 ‘’’ 运行结果如下： 1 Hello World ‘’’

#如果直接输出字符串，而不是用对象表示的话，可以不使用逗号 print(“Duan””Yixuan”) print(“Duan”,”Yixuan”)

‘’’ 运行结果如下： DuanYixuan Duan Yixuan 可知，不添加逗号分隔符，字符串之间没有间隔 ‘’’

print(“www”, “snh48”, “com”, sep=”.”) # 设置间隔符 ‘’’ 运行结果如下： www.snh48.com ‘’’

②变量输出

无论什么类型的数据，包括但不局限于：数值型，布尔型，列表变量，字典变量…都可以直接输出。

示例：

#例如：

num = 19 print(num) #19 输出数值型变量

str = ‘Duan Yixuan’ print(str) #Duan Yixuan 输出字符串变量

list = [1,2,’a’] print(list) #[1, 2, ‘a’] 输出列表变量

tuple = (1,2,’a’) print(tuple) #(1, 2, ‘a’) 输出元组变量

dict = {‘a’:1, ‘b’:2} print(dict) # {‘a’: 1, ‘b’: 2} 输出字典变量

③格式化输出

在C语言中，我们可以使用printf(“%-.4f”,a)之类的形式，实现数据的的格式化输出。
在python中，我们同样可以实现数据的格式化输出。

示例：

s=’Duan Yixuan’x=len(s) print(‘The length of %s is %d’ %(s,x))

‘’’ ‘The length of %s is %d’ 这部分叫做：格式控制符 (s,x) 这部分叫做：转换说明符 % 字符，表示标记转换说明符的开始 输出如下： The length of Duan Yixuan is 11 ‘’’

最小字段宽度

转换后的字符串至少应该具有该值指定的宽度。如果是（星号），则宽度会从值元组中读出。
点(.)后跟精度值：如果需要输出实数，精度值表示出现在小数点后的位数。如果需要输出字符串，那么该数字就表示最大字段宽度。如果是，那么精度将从元组中读出。

%后跟宽度值

可参考C语言的实现方式。

注：字段宽度中，小数点也占一位。

示例：

PI = 3.141592653 print(‘%10.3f’%PI) #字段宽10，精度3 # 3.142

#精度为3，所以只显示142，指定宽度为10，所以在左边需要补充5个空格，以达到10位的宽度

PI=3.1415926 print(“PI=%.*f”%(3,PI)) #用*从后面的元组中读取字段宽度或精度,可以读取出来精度是3位 #PI=3.142

#没有指定宽度，所以不需要缩进

print(“PI=%*.3f”%(10,PI)) #精度为3，总长为10. # PI= 3.142

#* 所处的位置不同，读取的内容也不同

转换标志

-表示左对齐；

PI=3.1415926 print(‘%-10.3f’ %PI) #左对齐，还是10个字符，但空格显示在右边。 #3.142

+表示在数值前要加上正负号；

PI=3.1415926 print(‘%+f’ % PI) #显示正负号 #+3.141593 # 类型f的默认精度为6位小数。

“ “(空白字符)表示正数之前保留空格()；

pi = 3.14 print(‘% f’%pi) # 3.14

0表示转换值若位数不够则用0填充。

PI=3.1415926 print(‘%010.3f’%PI) #字段宽度为10，精度为3，不足处用0填充空白 #000003.142 0表示转换值若位数不够则用0填充

格式化字符归纳

格式字符说明格式字符说明

%s 字符串采用str()的显示 %x 十六进制整数

%r 字符串(repr())的显示 %e 指数（基底写e）

%c 单个字符 %E 指数（基底写E）

%b 二进制整数 %f,%F 浮点数

%d 十进制整数 %g 指数(e)或浮点数(根据显示长度)

%i 十进制整数 %G 指数(E)或浮点数(根据显示长度)

%o 八进制整数 %% 字符%

2、input

无论我们输入的值是int，float还是sring，最后input（）函数返回的这个数据的类型均为string型
所以，当我们使用input（）函数输入的数据进行算术运算时，我们大多需要使用强制类型转换来允许我们计算。

强制类型转换

①在键入时进行转换

a = int（input()）

②在使用时进行转换

a =input(); b=input(); c= int(a)+int(b);

这样赋值的数据存储的形式仍是input（）返回的字符串类型，仅仅在使用时转换，会加大工作量，且有可能因为粗心带来报错，所以要谨慎使用。[

](https://blog.csdn.net/sinat_28576553/article/details/81154912)

带提示的input

prompt——提示

variable = input(prompt)

示例：

name = input(‘请输入您的名字’) print(name) #结果 请输入您的名字小日 小日

带变量的提示：
示例：

Sno = input(‘请输入’+str(name)+’同学的学号’) #注意，因为提示只能用字符串变量进行输出，因此，要用强制类型转换，并且要用连接字符串的 + ，而不是分割字符串的，

一次给多个变量赋值

（1）：利用split（）函数进行输入

同时，我们不仅可以利用split（）函数一次性输入多个数，我们还可以设置分隔符，除了传统的空格形式，也可以用逗号“，”这种更符合语言习惯的方式分隔输入字符。其原理是因为input（)输入了一个字符串，而split（）函数能根据设定的分割点分割字符串并返回分割后的字符串列表，所以能实现一次性输入多个数据值。

示例：

a,b,c = input(‘以空格隔开’).split() #结果 #以空格隔开3 4 5
a,b,c = input(‘以逗号隔开’).split(“,”) #结果 #以逗号隔开3,4,5

（2）：类型转换

map（）将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。我们将传入的函数设置为强制类型转换函数int，则split()函数返回的列表里的每一个值都将被强制转换类型，从而实现多输入的类型转换。
示例：

d,e,f = map（int，input(‘以逗号隔开’).split(“,”)） print(d,e,f) #结果 以逗号隔开1，2，3 1 2 3

Python 基础