Python基础

输出函数print()

输出内容可以是

1.数字 print(66.6)
2.字符串
print(‘hello world’)
#单引号双引号都可
3.含有运算符的表达式
print(3 + 1)
4.输出到文件中
fp = open(‘D:text.text’,‘a+’)
print(‘hello world’,file = fp) fp.close()
#a+ 以读写的方式打开文件，若文件不存在就创建文件，文件存在就在原有的基础上追加
#注意点：盘符存在，要用file =
5.不进行换行输出（输出内容在一行）
print（‘hello’,‘world’,‘python’）
6.print(‘输出内容’,end = ‘t’) 不换行输出，以一个制表符分开
7.print（）默认换行，如果想要修改，添加一个参数end = ‘’,自行修改

转义字符

n 换行
t 水平制表符 4个空格
r 回车
print（‘hello r world’）回车时hello被world替代掉
b 退一个格
在引用单引号、双引号、时 要加 ,也可以在字符串之前加上r或R,最后一个字符不能是 ,但可以是两个
print(r’hellonworld’)

二进制与字符编码

计算机只能识别0、1 ->编成一个ASCII表
80 年代推出GB2312 ，能够识别简体中文7445个字符
90年代推出GBK，简体和繁体
00年代推出GB18030 27484个字符中文，加藏文等少数名族字符
Unicode 几乎包含了全世界所有的字符，
utf-8 中文3个字节代表一个汉字

print(chr(0b100111001011000) ) 输出“乘”
print(ord(‘乘’)) 输出2056，即上面的二进制的十进制表达

标识符和保留字

在Python中输入以下，打印出保留字列表
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’]

命名规则：
字母、数字、下划线_
不能以数字开头，不能是保留字，严格区分大小写

变量的定义和使用

变量由三部分组成：
1.标识：对象所存储的内存地址，使用内置函数id（obj）来获取
2.类型：对象的数据类型，使用内置函数type（obj）来获取
3.值：对象所存储的具体数据，使用pring（obj）可以将值进行打印输出
例：
name = ‘玛丽’
print(‘标识’，id(name))
print(‘类型’，type(name))
print(‘值’，name)

常用数据类型

整数 int
浮点 float
对于浮点数的计算，直接计算会出现偏差，用下面的模板
from decimal import Decimal
print（Decimal（‘1.1’）+ Decimal（‘2.2’））

布尔 bool ->True,False
1.用来表示真假的值
2.布尔值可以转换成整数1,0
直接进行运算

字符串类型 st
1.又称为不可变的字符序列
2.可以使用单引号，双引号，三引号
1）单引号，双引号定义的字符必须在一行
2）三引号"""定义的字符串可以分布在连续的多行(三个单引号或双引号都可)

数据类型转换

为何转换：将不同的数据类型的数据拼接在一起
例：
name = ‘张三’
age = 20
print（‘我叫’+ name + ‘，今年’ + str（age）+ ‘岁’）
将int类型通过str（）转换成str类型
1.str（） 转成str类型
2.int（） 转成int类型
str转成int，str里为整数可以，小数，字符串不可以
float 转成int，只截取整数
bool转成int ，1或0
3.float（） 转成浮点数
str转成float，str里为float类型的数，若为整数类型，则会在末尾加.0，若为文字，则不可以
bool转float，加.0
int转float ，加.0

注释

#单行注释，直到换行

三引号不赋值，代表多行注释

中文编码声明，在文件开头#coding：utf-8，gbk等，找到文件以记事本打开可以看到存储的编码格式

输入函数input（）

1.作用：接收来自用户的输入
2.返回值类型：输入的类型为str
3.值得存储：使用= 对输入的值进行存储
例 ：
a = int(input(“请输入一个整数”))

运算符

标准运算符 ：加+，减-，乘*，除/，
整除//
一正一负的整除，向下取整
取余运算符 ：%
取余与除数的正负一致
幂运算符 ：**
2**3,2的三次方

赋值运算符 =
执行顺序：右->左
支持链式赋值： a=b=c=1
支持参数赋值： +=，-=，*=，/=，//=，%=
支持系列解包赋值 a,b,c= 1,2,3
两个值的交换 a,b = b,a

比较运算符,结果为bool类型
< ,>,>=,<=,!=,==
is , is not

==，比较的是value值，
is 比较的是id标识

bool运算符
and 都真为真
or 有真为真，都假为假
not 真为假，假为真
in 在…里
not in 不在…里
例：
str= ‘helloworld’
print(‘w’ in str) ->True

位运算符 转换成二进制
位与&
都1为1，有0为0
位或 |
都0为0，有1为1
左移<<，相当于乘2
高位溢出舍弃，低位补0
右移>>
低位溢出舍弃，高位补0

运算符的优先级

1.**
2./ ,// %
3. + -
4.<< >>
5.&
6.|
7.>,<,>=,<=，==，！
8.and
9.or
10.=
（）>算数运算 >位运算>比较运算符 >bool运算 >赋值运算

对象的布尔值

以下为False：
False
数值0
None
空字符串
空列表
空元组
空字典
空集合
其他为True

选择结构

if 条件表达式 ：
执行语句1
else if ：
执行语句2
else ：
执行语句3

pass语句

只是一个占位符，用在语法上需要语句的地方
什么时候使用：
先搭建语法结构，还没想好代码怎么写的时候
哪些语句一起使用：
1.if语句的条件执行体
2.for-in语句的循环体
3.定义函数时的函数体

range()函数

用于生成一个整数序列
三种方式生成：
1.range(stop),创建 一个[0- stop) 的数，步长为1
2.range(start,stop)创建一个[ start-stop) 的整数序列，步长为1
3.range(start,stop,step)创建一个[ start-stop) 的整数序列，步长为step
例：
r = range(10)
print® #显示（0,10）
借用list显示全部
print（list（r）） #查看range对象中的整数序列
用in或not in判断是否包含
range类型的优点：
不管range对象表示的整数序列有多长，所有range对象的内存空间都是相同的，因为仅仅需要存储start，stop和step，只有当用到range对象时，才会计算序列中的相关元素

循环结构

while循环

while 条件表达式：
循环体

for-in循环

in表达从（字符串，序列）中依次取值，又称为遍历

for-in遍历的对象必须是可迭代对象

语法：
for 自定义的变量 in 可迭代对象：
循环体

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

例：
for item in ‘python’:
print(item)
依次取一个字母打印

for i in range(10):
print（i）
打印0-9

流程控制语句break，continue

break用于结束循环结构。通常与分支结构if一起使用
continue，用于结束当前循环，进入下一次循环，通常与分支结构中的if一起使用
多重循环中的break和continue只控制本层循环

else语句搭配

if …else : if表达式不成立时执行else
while…else,for…else:没有碰到break时执行else
例：
for i in range（3）：
pwd = input(‘请输入密码’)
if pwd ==‘8888’:
print('密码正确‘）
break
else：
print(‘密码不正确’)
else:
print(‘三次输入错误’)

列表 list创建与查询

列表相当于其他语言中的数组

1.列表创建
list = [’ ’ , ’ ']
也可以调用内置函数list（）
list = list（[ ]）
空列表创建：
1.name[]
2.name = list()
2.列表特点
1）列表元素按顺序有序排序
2）索引映射唯一的数据
3）列表可以存储重复的数据
4）任意类型数据混合存储
5）根据需要动态分配内存和回收内存

3.获取索引
print（list.index（‘内容’））
1）若有多个内容相同，返回第一个的索引
2）list.index（‘内容’，start，stop），从索引 [start,stop)开始查找
3）按顺序索引从0开始，倒序索引从-1开始

4.列表元素的查询操作
语法：
list[ start : stop : step]
1）切片的结果，产生的一个新的列表
2）step为1，可简写[start : stop
3)step 为正数
[ : stop : step] 切片的第一个元素是列表的第一个元素
[ start : : step] 切片的最后一个元素是列表的最后一个元素
4）step为负数
[ : stop :step] 切片的第一个元素默认是列表的最后一个元素
[start : : step]切片的最后一个元素默认是列表的第一个元素
5）判断元素是否在列表中存在
用in或not in

5.列表的遍历
print(list(表名))
for 迭代变量 in 列，表，名：
操作
例：
lst = [1,2,3,4,5]
for item in lst:
print(item)

列表的增加

1.向列表的末尾添加一个元素append（）
list.append(数据)
new_list = [ ]
list.append(new_list) # 将新表作为一个元素添加到末尾
2.在列表的末尾至少添加一个元素extend（）
list.extend（new_list）#将new_list里的元素逐个添加到末尾

3.在列表的任意一个位置添加一个元素insert（）
list.insert（index，数据）

4.在列表的任意一个位置添加至少一个元素-----切片
list[index:] = new_list #在索引后切掉，然后将new_list里的元素添加进去

列表的删除

1.list.remove（数据）
移除一个元素，若有重复元素，则移除第一个元素
2.pop（）删除指定
list.pop（index）#不指定索引，则删除列表的最后一个元素
3.切片删除，将产生新列表
new_list = list[start：stop] #将[start,stop)删除
4.不产生新的列表的删除
list[start：stop] = [ ]
5list.clear（）清空列表
6.del list------删除列表

列表修改

1.为指定索引赋一个新值
list[index] = 新值
2.切片赋值
list[start : stop] = [数据1，数据2，…]
将start与stop切掉，换成新数据

列表的排序操作

常见的两种排序操作

1.调用sort（）方法，列表中的所有元素按照从小到大的顺序进行排序，可以指定reverse = True，进行降序排序，reverse= False 升序

list.sort（） 默认升序
list.sort（reverse = True）降序排序
2.调用内置函数sorted（），可以指定reverse = True，进行降序排序，原列表不发生改变，产生一个新的列表
new_list = sorted(list) #升序
new_list = sorted(list，reverse = True)

列表生成式

list = [i for item in range(1,10)]
前面的i是关于item的表达式

字典

Python内置的数据结构之一，与列表一样是一个可变序列
以键值对的方式存储数据，字典是一个无序的序列
用花括号括起来
scores（字典名） = { ‘name1’: data1,‘name2’: data2…}
: 之前称键，之后称为值，一起叫键值对
放的位置是经过hash函数计算的来，所以无序

字典的创建

1.使用花括号{}
scores = {键1：值1，键2 ： 值2…}
2.使用内置函数dict（）
变量名 = dict（键1= 值1，键2 = 值2 ）
3空字典
变量名 = {}
name = dict（）

字典元素的获取

1.sores[键]
2.scores.get(键)
区别：
若查找的键不存在，[]会报错，get（）会输出None
scores.get(键，data)，若查找的不存在，输出data

字典的常用操作

字典判断

key键的判断，-----in或not in

删除指定键值对

1.del scores[键]
2.scores.clear（） #清空字典

新增字典元素

scores[键] = data # 将这个键值对插入字典

获取字典视图的三个方法

1.keys() # 获取字典中所有的键
name=scores.keys() #name类型为列表
2.values() #获取字典中所有的value
name1 = scores.values() #同上
3.items() #获取字典中所有的键值对
name2 = scores.items() #新类型为列表，列表里的元素为元组，（）括起来

字典元素的遍历

for item in scores:
print(item，scores.get（item）)或print（item，scores[item]）

字典的特点

1.所有元素都是键值对，键不可以重复，若重复后，值会被覆盖，而值可以重复，
2.字典元素是无序的
3.键必须是不可变对象
4.字典也可以根据需要动态收缩
5.字典会浪费较大的内存，是一种时间换空间的数据结构
#查询比较快，但是占用空间比较大

字典生成式

1.内置函数zip()
items = [key1,key2,key3,…]
prices = [value1,value2,value3,…]
name = zip(items,prices)
#将key，和value分开写，用zip（）函数压缩成字典

例：
items = [‘a’,‘b’,‘c’]
prices = [1,2,3]
scores = {item.upper() : prices for item in zip(items,prices)}
#items 变大写
#在压缩过程中，以短的进行压缩

元组

元组是Python的内置数据结构之一，是不可变序列
不可变序列：字符串，元组
#没有增删改的操作
可变序列：字典列表
#可以对序列进行增删改操作，对象地址不发生更改

元组的创建方式

1.使用（）
name = (data1,data2,data3…)
#（）可省略不写，若元组中只包含一个元素，则必须加（）与‘，’
不加会认为是本身的类型
2.使用内置函数tuple（）
name = tuple((data1,data2,data3))
3.空元组的创建方式
1.name =（）
2.name1 = tuple（）

为什么将元组设置成不可变序列

1.在多任务环境下，同时操作对象不需要加锁
2.元组中尽量使用不可变序列
注意事项：
1.若元组中的对象本身不可变，则不能在引用其他的对象
2.若元组的对象时可变的，则可变对象的引用不允许改变，但数据可以改变

元组的遍历

元组是可迭代对象，可以用for in遍历
1.可以用索引，前提需要知道元组中元素的个数
2.遍历元组
for item in tuplename：
print（item）

集合

1.Python提供的内置数据结构，与列表，字典一样都属于可变类型的序列
2.集合是没有value的字典

集合的创建

1.直接{}
name = {data1，data2，data3…}
#集合里面的数据不能重复
2.内置函数set（）
1）name = set(range(6))
#产生一个[0,6)的整数集合
2）name1 = set([ data1,data2,data3,…])
#将列表元素转换成集合元素，同时去掉列表中的重复元素
3）name2 = set（（data1，data2，data3…））
#将元组中的元素转换成集合元素，不一定按照原来的顺序，因为集合经过哈希计算存储位置后，顺序是不定 的
4）name3 = set（‘str’）
#将字符串转换成集合里的元素

空集合的创建

不能使用{}直接创建集合，否则创建的是空字典
使用内置函数创建
name = set（）

集合的判断

in 或not in

集合元素的新增

1.add（）依次增加一个
name.add(data)
2.update() 一次至少增加一个元素
name.update（data1，data2，…）
#可以放一个集合，列表，元组

集合的删除

1.remove（）
name.remove(data)
#一次删除一个指定元素，指定元素不存在则跑出KeyError
2.discard（）
name.discard(data)
#一次删除一个指定元素，指定元素不存在不抛出异常
3.pop（）
name.pop()
#一次只删除一个任意元素，没有参数
4.clear（）
name.clear()清空集合

集合间的关系

1.name1 == name2 #判断集合是否相等

2.name1.issubset(name2)
#判断name1是否是name2 的子集

3.name1.issuperset（name2）
#判断name1 是否是name2 的超集，就是包含的意思

4.name1.isdisjoint(name2)
#判断是否有交集，没有为True，有为False

集合的数学操作

1.交集
name1.intersection（name2）
name1 & name2
2.并集
name1.union（name2）
name1 | name2
3差集 A-A∩B
name1.difference（name2）
name1 - name2
4.对称差集 （A-A∩B）∪（B-A∩B）
name1.symmetric_difference（name2）
name1 ^ name2

集合生成式

s = { i*i for i range(6)}
将列表生成式的[ ]改成{}就是集合生成式

列表、字典、元组、集合总结

字符串的驻留机制

字符串在Python中是基本的数据类型，是一个不可变的字符序列

字符串的驻留机制：
对相同的字符串只保留一份拷贝，后续创建相同的字符串时，不会开辟新的空间，而是把该字符串的地址赋给新创建的变量

驻留机制的几种情况（交互模式）

1.字符串的长度为0或1时
2.符合标识符的字符串
3.字符串只在编译时进行驻留，而非运行
4.[-5,256]之间的整数数字

5.通过is判断是否同一个内存
sys中的intern方法强制2个字符串指向同一个对象
a = ‘abc%’
b = ‘abc%’
a = sys.intern(b)

pycharm对字符串进行了优化处理

字符串驻留机制的优缺点

1.当需要相同的字符串时，可以直接从字符串池里拿来用，避免频繁的创建与销毁，提升效率和节约内存，因此，拼接字符串和修改字符串时比较影响性能的

2.在需要进行字符串拼接时建议使用str类型的join方法而非+，因为join（）方法是先计算出所有字符串中的长度，然后再拷贝，只new一次对象，效率要比“+”高

字符串的查询操作

1.index（）
str = ‘hello world’
str.index(‘lo’)
查找子串substr第一次出现的位置，如果查找的子串不存在时，抛出ValueError
2.rindex（）
查找子串substr最后一次出现的位置，如果查找的子串不存在时，抛出ValueError
3.find（）
查找子串substr第一次出现的位置，如果查找的子串不存在时，返回-1
4.rfind（）
查找子串substr最后一次出现的位置，如果查找的子串不存在时，返回-1

字符串的大小写转换操作

产生一个新的字符串对象，开辟新的内存
1.upper（）
转换成大写
2.lower（）
转换成小写
3.swapcase（）
大写转成小写，小写转成大写
4.capitalize（）
第一个字符大写，其它小写
5.title（）
每个单词的第一个字符转成大写，剩余转成小写

字符串内容对齐操作

1.center（）
居中对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
2.ljust（）
左对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
3.rjust（）
右对齐，第一个参数指定宽度，第二个参数指定填充符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
4.zfill（）
右对齐，左边用0 填充，该方法只接受一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

字符串的劈分操作

1.split（）
1）从左侧开始劈分，默认劈分字符是空格，返回的值都是一个列表
2）通过参数sep指定劈分符
str = ‘hello world | python’
str.split(sep = ‘|’)
3）通过参数maxsplit指定劈分字符串时的最大劈分次数，经过最大劈分次数后，右边剩余的会作为一个整体单独作为一部分
str.split(sep = ‘|’ , maxsplit = 1)

2.rsplit()
1）从右侧开始劈分，默认劈分字符是空格，返回的值都是一个列表
2）通过参数sep指定劈分符
str = ‘hello world | python’
str.split(sep = ‘|’)
3）通过参数maxsplit指定劈分字符串时的最大劈分次数，经过最大劈分次数后，左边剩余的会作为一个整体单独作为一部分
str.split(sep = ‘|’ , maxsplit = 1)

判断字符串的操作

1.isidentifier()
判断字符串是不是合法的标识符
2.isspace（）
判断指定的字符串是否全部由空白字符组成（回车、换行、水平制表符）
3.isalpha（）
判断指定的字符串是否全由字母组成
4.isdecimal（）
判断字符串是否由十进制的数字组成
5.isnumeric（）
判断是否全由数字组成
6.isalnum（）
判断字符串是否由字母和数字组成

字符串的常用操作

1.字符串替换 replace（）
第1个参数指定被替换的字符串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法可以通过第3个参数指定最大替换次数

2.合并join（）
将列表或元组的字符串合并成一个字符串
s = ‘hello’
s = (‘hello’,‘sasd’,‘asffav’)
s = [‘da’,‘fsfw’,‘afs’]
print(’*’ .join(s))

字符串的比较操作

运算符： > , >= , < , <= ,== , !=

1.比较规则
首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再进行比较

2比较原理
两个字符进行比较时，比较的是其ordinal value（原始值），调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value 可以得到其对应的字符

==与is的区别

== 比较的是值的大小
is 比较的是id的地址是否一样

字符串的切片操作

1.字符串时不可变序列
1）不具备增删改等操作
2）切片操作将产生新的对象
[start:stop:step] #[start,stop) 切片,步长为step
s = ‘hello,world’
s1 = s[:5] #切到5

格式化字符串

1.%
% 占位符
%s 字符串
%i或%d 整数
%f 浮点数
例：
name =‘张三’
age = 20
print(‘我叫%s,今年%d岁’%(name,age))
2. {}
例：
name =‘张三’
age = 20
print(‘我叫{0},今年{1}岁’.format(name,age))
{0 ：.3} 后面的表示一共三位
{0 ：.3f} 后面的表示3位小数
{0 ：10.3f} 后面的表示3位小数,设置10位宽度

3.f格式化
name =‘张三’
age = 20
print(f’我叫{name},今年{age}岁’)

4.数字精度
print(’%10d’ % 99) #宽度为10
print（‘%.3f’ % 3.14159） 保留3位有效小数

字符串的编码转换

s = ‘海上生明月’
#编码
print(s.encode(encoding = ‘GBK’)) #一个中文占两个字节
print(s.encode(encoding = ‘UTF-8’)) #一个中文占三个字节

#解码，b代表一个二进制数据（字节类型的数据）
b=s.encode(encoding = ‘GBK’)
print(b.decode(encoding = ‘GBK’))

函数

1.复用代码
2.隐藏实现细节
3.提高可维护行
4.提高可读性，便于调试

函数的创建

def 函数名（[输入参数]）
函数体
[return xxx]
#关键字参数传参
根据形参的名字，来传递实际参数

函数调用过程中，不可变对象在函数体内的修改不会影响实参的值
如果是可变对象，在函数体内的修改会影响实参的值

函数的返回值

1.若没有返回值，return可以省略不写
2.函数的返回值，若只有一个，直接返回类型
3.若返回值有多个，返回的结构为元组

函数定义默认参数

1.给形参设置默认值，只有与默认值不同的时候才需要传递实参

2.个数可变的位置参数

一个*为元组，两个为字典
个数可变的位置形参只能有一个 *
个数可变的关键字形参只能有一个 **

在函数定义中，既有个数可变的位置形参，也有个数可变的关键字形参，要求个数可变的位置形参，放在个数可变的关键字形参前面

变量作用域

局部变量 用global声明，就变成了全局变量

递归函数

在一个函数体内，继续调用函数本身，称为递归

1.递归的组成部分
递归调用，与递归终止条件

2.递归的调用过程
1）每递归调用一次函数，都会在栈内分配一个栈帧
2）每执行完一次函数，都会释放相应空间

3）递归的优点与缺点
优点：
占用内存多，效率低下
缺点：
思路与代码简单

Python的异常处理机制

try
except

最后

以上就是天真电脑为你收集整理的Python基础的全部内容，希望文章能够帮你解决Python基础所遇到的程序开发问题。

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