输出函数：print

可以输出数字、字符串、含有运算符的表达式

数字：print(1)    print(2)

字符串：print("hello world")   print('hello')

含有运算符的表达式：print(1+3)  输出的是4    print("1+3") 输出的是1+3

可以将内容输出到显示器、文件

print(1) 将1输出到显示器中

fp=open("F:/text.txt","a+")   #a+：如果文件不存在就创建，存在就在文件内容的后面继续追加
print("helloworld",file=fp)   #把helloworld输出到文件中
fp.close()            

输出形式可以是换行、不换行

print("hello","world","python")     #这三个单词将在一行输出

转义字符

反斜杠加上想要实现转移的字母

• 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转移
• 当字符串中包含换行、回车等无法直接表示的特殊字符时，也可使用转义字符（换行：n Tab：t）

原字符：不希望字符串中的转义字符起作用，就使用原字符，即在字符串前加r、R

print(r"hellonworld") 输出hellonworld 注意：最后一个字符不能是反斜线

python中的标识符和保留字

标识符

变量、函数、类、模块和其他对象起的名字就叫做标识符

• 以字母、数字、下划线组成
• 不能以数字开头
• 不能是保留字
• 严格区分大小写

保留字

有一些单词被赋予了特定的意义，这些单子在给任意对象起名字是都不能用

变量

变量由三部分组成

• 标识：标识对象存储的内存地址，使用内置函数id(obj来获取)
• 类型：标识对象的数据类型，使用内置函数type(obj)来获取
• 值：标识对象存储的具体数据，使用print(obj)可以将值输出

在多次赋值之后，变量会指向新的空间

数据类型

整数类型(int)

可以表示正数、负数、零

整数的各种进制表示

• 十进制： 默认
• 二进制： 以0b开头
• 八进制： 以0o开头
• 十六进制： 以0x开头

浮点数类型(float)

布尔类型(bool)

字符串类型(str)

三引号里的字符串会根据输入的格式输出（""“str1"”" ， ‘’‘str2’’’）

str3="""hello 
world"""           

输出是：hello
world

类型转换

转换为整型：int()

将str转成int类型，字符串必须为数字串（整数）

将float转成int类型，截取整数部分，舍掉小数部分

转化为字符型：str()

转换为浮点型：float()

整数类型转换为浮点型是后面加 .0

布尔类型转换为浮点型是 true变成1.0 false变成0.0

字符串中的数据如果是非数字串则不允许转换

注释

单行注释#

多行注释 ‘’’ 或 “”"

中文编码声明 #coding:utf-8

input()函数

用来接收用户的输入，类型为str

运算符

算术运算符

标准算数运算符

• 加 +
• 减 -
• 乘 *
• 除 /
• 整除 // （一正一负向下取整）

取余运算符

% (一正一负用公式：余数=被除数-除数*商)

幂运算符

**

赋值运算符

执行顺序：从右到左

支持链式赋值：a=b=c=1 （存储地址相同）

支持参数赋值： += -= *=

支持系列解包赋值：a,b,c=1,2,3 （a,b=b,a交换值）

比较运算符

<,>,<=,>=,!=

== 比较对象的值

is,is not 比较对象的id

布尔运算符

布尔值之间的运算（and/or/not/in/not in）

and：两者都为true则为true

or：两者有一个为true则为true

not：对布尔值取反

in：判断一个字符串是否在另一个字符串中

not in：判断一个字符串是否不再另一个字符串中

位运算符

将数据转成二进制进行计算

位与（&）

对应位数都是1，结果才为1，否则为0

位或（|）

对应位数都是0，结果才为0，否则为1

左移位运算符（<<）

高位溢出舍弃，低位补0（相当于乘2）

右移位运算符（>>）

低位溢出舍弃，高位补0（相当于除以2）

运算符的优先级

算数运算符>位运算符>比较运算符>布尔运算符

1. **
2. *,/,//,%
3. +,-
4. <<,>>
5. &
6. |
7. ,<,>=,<=,==,!=
8. and
9. or
10. =

流程控制

顺序结构

程序从头到尾按顺序执行，中间没有判断和跳转

选择结构

python一切皆对象，所有对象都有一个布尔值，可以使用内置函数bool()获取对象的布尔值

（False、数值0、None、空字符串、空列表、空元组、空字典、空集合）的布尔值是False，其他对象的布尔值均为True

单分支结构

if 条件表达式:

​ 条件执行体

money=100
i=int(input("请输入取款金额"))
if i<money:
    money=money-i
    print("余额",money)

双分支结构

if 条件表达式:

​ 条件执行体1

else:

​ 条件执行体2

money=100  
i=int(input("请输入取款金额"))
if i<money:
    money=money-i
    print("余额",money)
else:
    print("余额不足")

多分支结构

if 条件表达式1:

​ 条件执行体1

elif 条件表达式2:

​ 条件执行体2

elif 条件表达式N:

​ 条件执行体N

[else:]

​ 条件执行体N+1

i=int(input("请输入成绩："))
if i>=90 and i<=100:
    print("您的等级是A")
elif i>=80 and i<90:
    print("您的等级是B")
elif i>=70 and i<80:
    print("您的等级是C")
elif i>=60 and i<70:
    print("你的等级是D")
elif i>=0 and i<60:
    print("您的等级是E")
else:
    print("您的成绩有误")

嵌套if

if 条件表达式1:

​ if 内层条件表达式:

​ 内层条件执行体1

​ else:

​ 内层条件执行体2

else:

​ 条件执行体

条件表达式

x if 判断条件 else y

如果判断条件为true，条件表达式返回x，否则返回y

print(5 if 5<=7 else 7)        #输出5

循环结构

range()函数的使用

range()用于生成一个整数序列（所有range对象占用内存空间是相同的）（in和not in可以判断序列中是否存在指定整数）

可以使用list()函数把数字都列出来

• range(x)：创建一个(0,x)之间的整数序列，步长为1（不包含x）
• range(x,y)：创建一个(x,y)之间的整数序列，步长为1（不包含x）
• range(x,y,z)：创建一个(x,y)之间的整数序列，步长为z

x=range(10)
print(x)                #输出range(0, 10)
print(list(x))          #输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

x=range(5,13)
print(x)                #输出range(5, 13)
print(list(x))          #输出[5, 6, 7, 8, 9, 10, 11, 12]

x=range(1,13,3)
print(x)                #输出range(1, 13, 3)
print(list(x))          #输出[1, 4, 7, 10]

while循环

while 条件表达式:

​ 条件执行体

a=1
while a<=5:
    print(a)
    a+=1            #输出12345

for-in循环

for-in循环的对象必须是可迭代对象（字符串和序列）

for 自定义的变量 in 可迭代对象:

​ 循环体

sum=0
for i in range(1,101):
    sum=sum+i
print(sum)					#输出1到100的整数和

循环体内不需要访问自定义变量，可以将自定义变量替换为下划线

break、continue与else语句

break语句（只影响本层循环）

用于结束循环结构，可以和if一起使用

for … in …:

​ …

​ if …:

​ break

for item in range(3):
        i = int(input("请输入密码："))
        if i==8888:
                print("密码正确")
                break
        else:
                print("密码错误")

while …:

​ …

​ if …:

​ break

a=0
while a<3:
        i=int(input("请输入密码："))
        if i==8888:
                print("密码正确")
                break
        else:
                print("密码错误")
                a+=1

continue语句（只影响本层循环）

用于结束当前循环，进入下一循环，可以和if一起使用

for … in …:

​ …

​ if …:

​ continue

​ …

for item in range(1,100):
        if item % 10 == 0:
                continue
        print(item)

while …:

​ …

​ if …:

​ continue

​ …

else语句

else和if搭配：if条件表达式不成立时执行else

else和while、for搭配：没有遇到break时，执行else

嵌套循环

循环结构中嵌套了另一个循环，内层循环作为一个外层循环的执行体

列表

• 列表可以储存N个元素，程序也可以对这些元素进行整体操作，列表内储存的是元素的id值
• 列表可以存储重复数据
• 列表可以任意类型的数据混合存储
• 列表按顺序有序排列

列表的创建与删除

列表的创建

使用[ ]创建：a=[‘hello’,‘world’]

使用内置函数list()创建：a=list([‘hello’,‘world’])

列表的删除

列表的查询操作

获取列表中指定元素的索引

使用index()：

列表中存在多个相同的元素，只返回相同元素中的第一个元素的索引

若查询的元素的索引不存在，则会显示ValueError

可以再指定的start和stop中查找

获取列表中的单个元素

正向索引从0到N-1

反向索引从-N到-1

若所查找的索引不存在，则显示IndexErrot

获取列表中的多个元素

列表名[start:stop:step]

列表元素的增、删、该操作

列表元素的增加

append()：在列表的末尾添加一个元素

lst=[1,2,3,4,5,6,7]
lst.append(9)
print(lst)				#输出[1, 2, 3, 4, 5, 6, 7, 9]

lst=[1,2,3,4,5,6,7]
lst2=[9,10]
lst.append(lst2)
print(lst)				#输出[1, 2, 3, 4, 5, 6, 7, [9,10]]

extend()：在列表的末尾至少添加一个元素

lst=[1,2,3,4,5,6,7]
lst2=[9,10]
lst.extend(lst2)
print(lst)				#输出[1, 2, 3, 4, 5, 6, 7, 9, 10]

insert()：在列表的任意位置添加一个元素

lst=[1,2,3,4,5,6,7]
lst.insert(1,6)
print(lst)				#输出[1, 6, 2, 3, 4, 5, 6, 7]

lst=[1,2,3,4,5,6,7]
lst2=[9,10]
lst.insert(1,lst2)
print(lst)				#输出[1, [9, 10], 2, 3, 4, 5, 6, 7]

切片：在列表的任意位置添加至少一个元素

lst=[1,2,3,4,5,6,7]
lst1=[10]
lst[2:5:1]=lst1
print(lst)				#输出[1, 2, 10, 6, 7]

列表元素的删除

remove()

• 一次删除一个元素
• 重复元素只删除第一个
• 元素不存在时输出ValueError

lst=[1,2,3,4,5,6,7,1]
lst.remove(1)
print(lst)				#输出[2, 3, 4, 5, 6, 7, 1]

pop()

• 删除第一个指定索引上的元素
• 指定索引不存在输出IndexError
• 不指定索引，删除列表中的最后一个元素

lst=[1,2,3,4,5,6,7,1]
lst.pop(1)
print(lst)				#输出[1, 3, 4, 5, 6, 7, 1]

切片

一次至少删除一个元素

lst=[1,2,3,4,5,6,7,1]
lst[1:3]=[]
print(lst)				#输出[1, 4, 5, 6, 7, 1]

clear()

清空列表

del

删除列表

列表元素的修改

为指定索引的元素赋予新值

lst=[1,2,3,4,5,6,7,1]
lst[3]=9
print(lst)			#输出[1, 2, 3, 9, 5, 6, 7, 1]

为指定切片赋予新值

lst=[1,2,3,4,5,6,7,1]
lst[1:3]=[10,10,10,10,10]
print(lst)			#输出[1, 10, 10, 10, 10, 10, 4, 5, 6, 7, 1]

列表元素的排列

使用sort()对列表进行排序默认是升序，可以指定reverse=True进行降序排序

lst=[1,2,3,4,5,6,7,1]
lst.sort()
print(lst)					#输出[1, 1, 2, 3, 4, 5, 6, 7]
lst.sort(reverse=True)
print(lst)					#输出[7, 6, 5, 4, 3, 2, 1, 1]

使用内置函数sroted()生成一个新的列表，可以指定reverse=True进行降序排序

lst=[1,2,3,4,5,6,7,1]
new_lst=sorted(lst)
print(new_lst)				#输出[1, 1, 2, 3, 4, 5, 6, 7]

列表生成式

[表示列表元素的表达式 for 自定义变量 in 可迭代对象]

lst=[i*2 for i in range(1,10)]
print(lst)						#输出[2, 4, 6, 8, 10, 12, 14, 16, 18]

字典

字典是python中内置的数据结构之一，是一个可变序列

字典以键值对的方式存储数据，是一个无序序列

键不可变（str）

通过hash函数计算存储位置找到值

键key不允许重复，值value可以重复

字典的创建和删除

字典的创建

使用花括号：scores={‘张三’:1,‘李四’:2,‘王五’:3}

scores={'张三':1,'李四':2,'王五':3}
print(scores)						#输出{'张三': 1, '李四': 2, '王五': 3}

使用内置函数dict()：dict()

print(dict(name='张三',age=25))		#输出{'name': '张三', 'age': 25}

字典的删除

字典的查询操作

[]：如果字典中不存在指定的key，则显示keyError

scores={'张三':1,'李四':2,'王五':3}
print(scores['张三'])					#输出1

get()：如果字典中不存在指定的key，则显示一个可以修改的默认参数

scores={'张三':1,'李四':2,'王五':3}
print(scores.get('张三'))				#输出1

sorses={'张三':1,'李四':2,'王五':3}
print(sorses.get('张四','不存在'))		#输出不存在

字典的增、删、改操作

字典的增加

sorses={'张三':1,'李四':2,'王五':3}
sorses['小明']=4
print(sorses)			#输出{'张三': 1, '李四': 2, '王五': 3, '小明': 4}

字典的删除

使用del删除指定键

sorses={'张三':1,'李四':2,'王五':3}
print(sorses.get('张四','不存在'))		#输出{'李四': 2, '王五': 3}

clear()

清空字典的元素

字典的修改

sorses={'张三':1,'李四':2,'王五':3}
sorses['张三']=4
print(sorses)							#输出{'张三': 4, '李四': 2, '王五': 3}

字典的视图获取

keys()：获取字典中所有key

values()：获取字典中所有的value

items()：获取字典中所有的key、value

字典生成式

{表示字典key的表达式:表示字典value的表达式 for 自定义表示key的变量,自定义表示value的变量 in 可迭代对象}

a=['张三','李四','王五']
b=[1,2,3]
c={a:b for a,b in zip(a,b)}
print(c)						#输出{'张三': 1, '李四': 2, '王五': 3}

内置函数zip()

a=['张三','李四','王五']
b=[1,2,3]
print(list(zip(a,b)))				#输出[('张三', 1), ('李四', 2), ('王五', 3)]

元组

字典是python中内置的数据结构之一，是一个不可变序列，无法进行增、删、改操作

元组的创建

()：a=(‘hello’,‘world’,1)

内置函数tuple()：t=tuple((‘hello’,‘world’,1))

只包含一个元素需要使用逗号和小括号：a=(1,)

集合

和字典类似，不能重复

集合的创建方式

s={}

使用内置函数set()，定义空集合：set()

print(set([1,2,3,4]))		#输出{1, 2, 3, 4}
print(set((1,2,3,4)))		#输出{1, 2, 3, 4}
print(set('hello'))			#输出{'l', 'e', 'h', 'o'}
print(set({1,2,3,4}))		#输出{1, 2, 3, 4}

集合的相关操作

集合元素的判断

in、not in

集合元素的增加

add()：一次添加一个元素

s1={1,2,3,4,5,6,7,8,9}
s1.add(10)
print(s1)					#输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

update()：一次至少添加一个元素

s1={1,2,3,4,5,6,7,8,9}
s1.update({20,19})
print(s1)					#输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 19, 20}

集合元素的删除

remove()：一次删除一个指定元素，若元素不存在则显示KeyError

s1={1,2,3,4,5,6,7,8,9}
s1.remove(5)
print(s1)				#输出{1, 2, 3, 4, 6, 7, 8, 9}

discard()：一次删除一个指定元素，指定元素不存在不显示异常

s1={1,2,3,4,5,6,7,8,9}
s1.discard(5)
print(s1)				#输出{1, 2, 3, 4, 6, 7, 8, 9}

pop()：一次只删除任意一个元素（不能添加参数）

s1={1,2,3,4,5,6,7,8,9}
s1.pop()
print(s1)				#输出{2, 3, 4, 5, 6, 7, 8, 9}

clear()：清空集合

s1={1,2,3,4,5,6,7,8,9}
s1.clear()
print(s1)				#输出set()

集合之间的关系

两个集合是否相等

使用运算符==或者!=

一个集合是否是另一个集合的子集

issubset()

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5}
print(s1.issubset(s2))		#False

一个集合是否是另一个集合的超集

issuperset()

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5}
print(s1.issuperset(s2))	#True

两个集合是否有交集

isdisjoint()：没有交集为True

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5}
print(s1.isdisjoint(s2))	#False

集合之间的数据操作

求交集

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.intersection(s2))	#输出{1, 2, 3, 4, 5}

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 & s2)				#输出{1, 2, 3, 4, 5}

求并集

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.union(s2))			#输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 | s2)				#输出{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

求差集

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.difference(s2))	#输出{8, 9, 6, 7}

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 - s2)				#输出{8, 9, 6, 7}

求对称差集

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1.symmetric_difference(s2))		#输出{6, 7, 8, 9, 10}

s1={1,2,3,4,5,6,7,8,9}
s2={1,2,3,4,5,10}
print(s1 ^ s2)						#输出{6, 7, 8, 9, 10}

集合生成式

{表示集合元素的表达式 for 自定义变量 in 可迭代对象}

s1={i*i for i in range(10)}
print(s1)				#输出{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

字符串

字符串是一个不可变的字符序列，对相同的字符串（符合标识符的字符串）只保留一份拷贝

字符串的创建

字符串的操作

字符串的查询操作

index()：查找字符串第一次出现的位置，若字符串不存在，则显示ValueError

a='helloworld'
print(a.index('ow'))		#输出4

rindex()：查找字符串最后一次出现的位置，若字符串不存在，则显示ValueError

a='helloworld'
print(a.rindex('l'))		#输出8

find()：查找字符串第一次出现的位置，若字符串不存在，则显示-1

a='helloworld'
print(a.find('l'))			#输出2

rfind()：查找字符串最后一次出现的位置，若字符串不存在，则显示-1

a='helloworld'
print(a.rfind('l'))			#输出8

字符串的大小写转换操作

upper()：将字符串中所有的字符都转成大写字母

a='hello world'
print(a.upper())		#输出HELLO WORLD

lower()：将字符串中所有的字符都转成小写字母

a='hello WORLD'	
print(a.lower())		#输出hello world

swapcase()：将字符串中所有的字符都转成大写字母，将字符串中所有的字符都转成小写字母

a='hello WORLD'
print(a.swapcase())		#输出HELLO world

capitalize()：把第一个字符转换为大写，其余转换为小写

a='hello WORLD'
print(a.capitalize())		#输出Hello world

title()：把每个单词的第一个字符转换为大写，单词的剩余字符转换为小写

a='hello WORLD'
print(a.title())		#输出Hello World

字符串的内容对其操作

center()：居中对齐，第一个参数表示宽度，第二个参数指定填充符默认是空格

ljust()：左对齐，第一个参数表示宽度，第二个参数指定填充符默认是空格

rjust()：右对齐，第一个参数表示宽度，第二个参数指定填充符默认是空格

zfill()：右对齐，左边用0填充

字符串内容的劈分

split()：从字符串的左边开始劈分，默认劈分字符是空格，返回列表，通过参数sep指定劈分字符，通过参数maxsplit指定最大劈分次数

a='hello world python'
print(a.split())			#输出['hello', 'world', 'python']

rsplit()：从字符串的右边开始劈分，默认劈分字符是空格，返回列表，通过参数sep指定劈分字符，通过参数maxsplit指定最大劈分次数

字符串内容的判断

isidentifier()：判断字符串是否是合法字符

isspace()：判断字符串是否都由空白字符组成

isalpha()：判断字符串是否都由字母组成

isdecimal()：判断字符串是否都由十进制的数字组成

isnumeric()：判断字符串是否都由数字组成

isalnum()：判断字符串是否都由字母和数字组成

字符串的替换与合并

字符串的替换

replace()：第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，第三个参数指定最大替换次数

a='hello world world world'
print(a.replace('world','boy',2))		#输出hello boy boy world

字符串的合并

join()：将列表或元组中的字符串合并成一个字符串

a=['hello','world']
print('&'.join(a))				#输出hello&world

字符串的比较操作

使用运算符进行比较

比较规则：按顺序逐个比较字符串中的每一个字符

字符串的切片操作

字符串不具备增删改操作，切片会产生新的字符串

a=('hello,world')
print(a[:7])				#输出hello,w

格式化字符串

%占位符

name='小明'
age=10
print('我叫%s，今年%s岁'%(name,age))		#输出我叫小明，今年10岁

{}

name='小明'
age=10
print('我叫{0}，今年{1}岁'.format(name,age))		#输出我叫小明，今年10岁

f-string

name='小明'
age=10
print(f'我叫{name}，今年{age}岁')		#输出我叫小明，今年10岁

字符串的编码与解码

编码

encode()：encoding指示编码种类

解码

decode()：encoding指示解码种类

函数

函数的创建与调用

函数的创建

def 函数名（参数）

​ 函数体

​ return xxx

函数返回多个值时，结果为元组

函数的调用

函数名（实参）

函数的参数定义

使用*定义个数可变的位置参数

使用**定义个数可变的关键字参数

变量的作用域

局部变量

在函数内部定义使用的变量，只在函数内部有效，可以使用global变成全局变量

全局变量

函数外部定义的变量，可作用与函数内外

最后

以上就是爱笑硬币为你收集整理的python学习笔记输出函数：print转义字符python中的标识符和保留字变量数据类型注释input()函数运算符流程控制列表字典元组集合字符串函数的全部内容，希望文章能够帮你解决python学习笔记输出函数：print转义字符python中的标识符和保留字变量数据类型注释input()函数运算符流程控制列表字典元组集合字符串函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。