python基础复习
# **计算机基础**## **1、进制转换**
二进制转十进制：
```
11100011 转 十进制
1*2^0+1*2^1+1*2^2+0*2^3+0*2^4+0*2^5+1*2^6+1*2^7
十进制转二进制，逆序取余
1110 0011 转十六进制
8421 8421
1*8+1*4+1*2+0*1=14=D
0*8+0*4+1*2+1*1=3
可得 0xD3
```
注意：进制数的标识，10， 0x10， 0o10， 0b10
十进制 十六进制 八进制 二进制
## **2、源码、反码、补码**
```
源码：数字转成二进制后的原始数据
反码：源码取反
补码：反码+1
正数：三码是一样的
负数：三码不同
例如：-5
源码：10000101
反码：11111010
补码：11111011
计算机以补码来保存数据
```
# **一些基本概念**
## **1、注释**
代码、文档说明部分，不会被当作代码执行
## **2、关键字和保留字**
是python预定使用的一些单词，这些单词具有一定的功能作用，不能用于标识符命名
## **3、内置函数**
python提供使用的，可以直接使用的函数
例如：id(),type(),max(),min(),print(),input()
## **4、缩进**
四个空格或者是tab键，属于语法的一部分
## **5、变量**
定义：变量名=值，变量类型是由值来决定，属于松散类型
命名规则：由数字字母下划线组成，数字不能开头，不能使用关键字和保留字，区分大小写
命名规范：
驼峰命名法：单词首字母大写，首个单词全小写如：isFileExits
帕斯卡命名法：单词首字母全大写 如：IsFileExits
匈牙利命名法：类型标识+驼峰 如：nNum，fNum
命名尽量使用英文单词，单词要见名知意
函数命名：小写单词+下划线
## **6、数据类型**
可变与不可变在于变量是否可以被修改
基本类型
```
数字（Number）不可变类型
字符串（String）
单引号：'hello'
双引号："hello"
三引号：'''hello''','''world''' 可以换行，可以注释在开头位置
不可变类型
布尔（Boolean）
只有俩个值：Ture，False
不可变类型
字节串（bytes）
在字符串的前面+b
单引号：b'hello'
双引号：b"hello"
三引号：b'''hello''',b'''world''' 字节串按二进制解析
不可变类型
```
复合类型
```
列表（List）
元素类型任意,()]
可变类型
字典（Dict）
一组键值对：{键：值}
{1:56,2:'hello','name':'Tom'}
可变类型
注意：键必须是不可变类型，值是任意类型，键是不可重复类型，一般字符串作键
如果出现相同键，后面的会覆盖前面的
{}表示：空字典
如：d={} #d是字典类型，不是集合
元组（Tuple）
元素类型任意(1,'',[],{})
不可变类型
集合（Set）
可变类型但元素必须是不可变类型
{1,2,3} #正确
{1,2,} #错误
常用于数学运算
元素是不可重复的，可以用来去重即类型转换
如：a=
b=set(a) #列表转集合，达到去重目的
创建一个空集合必须用 set() 而不是 { }
类（Class）
```
## **7、输入、输出**
```
输入：
a=input()
输出：
print()
注意：换行问题，默认换行，如不换print(end='')
格式化输出：3种方式
print('%d') #格式化控制符：%d（整型），%f（浮点），%s（字符串）
如：print('你好，我叫%s，今年%d岁了'%('Tom',5))
print(.format())
如：print('我叫{}，今年{}岁了'.format('Tom',5))
print('我叫{0}，今年{1}岁了'.format('Tom',5))
print('我叫{1}，今年{0}岁了'.format(5,'Tom'))
print(f'{}')
如：name = 'Tom'
age = 5
print (f'我叫{name}，今年{5}岁了')
或者
print (f'我叫{name}，今年{age}岁了') #更多用于
```
## **8、运算符**
算数运算符
```
加减乘(*)除(/,//)，取余(%)，幂运算(**)
```
赋值运算符
```
=,+=,-+,*=,/=
```
逻辑运算符
```
逻辑或(or) 逻辑与(and) 逻辑非(not)
逻辑于和逻辑或是短路运算
```
位运算
```
按位于(&)按位或(|)异或(^)取反(~)左移(<<)右移(>>)
```
关系（比较）运算
```
<,>,==,!=,<=,>=
```
## **9、分支语句**
单分支
```
if 条件：
条件为真时，执行
```
双分支
```
if 条件：
条件为真时，执行
else：
条件为假时，执行
```
多分支
```
if 条件1：
条件为真时，执行
elif条件2：
条件为真时，执行
elif条件3：
条件为真时，执行
.....
else:
以上条件都为假时，执行
注意：
数字为0为假
字符串为空字符串为假
列表为空列表为假
元组为空元组为假
字典为空字典为假
```
嵌套
```
if 条件：
条件为真时，执行
if 条件：
条件为真时，执行
else：
条件为假时，执行
...
else：
条件为假时，执行
if 条件：
条件为真时，执行
else：
条件为假时，执行
...
```
## **10、循环语句**
for in
```
for 变量 in 序列：
循环体
执行次数取决于序列元素的个数
序列中的元素个数=len(序列)
```
while
```
while 循环条件：
循环体
循环次数不明确的时候使用
例如：
while True:
date_list = file.readline()
if date_list = []:
break
```
break，continue
```
break：跳出循环，如果有嵌套，只能跳出当前循环
continue：结束本次循环，回到循环条件重新判断是否继续执行
```
## **11、字符串对象常用方法**
返回新的字符串=字符串对象.方法名()
全大写upper()
```
全大写upper()
例如：
s = 'hello world'
ret = s.upper()
print(s,ret)
```
全小写lower()
```
全小写lower()
例如：
s = 'hello world'
ret = s.lower()
print(s,ret)
```
替换replace()
```
替换replace(原始子串,替换的子串,替换的个数)
例如：
s = 'hello world'
ret1 = s.replace('world','Tom')
ret2 = s.replace('l','L',2)
print(s,ret1,ret2)
```
删除变量 del
```
删除变量 del，不可删除字符串中的子串，由于字符串是不可变类型，只支持替换，可以替换成空
例如：
s = 'hello world'
del s #删除变量
print(s)
输出正确
s = 'hello world'
del s #删除字符串中的
print(s)
输出错误
错误信息：
del s
TypeError: 'str' object doesn't support item deletion
如果删除字串，可以使用替换，替换为空
例如：
s = 'hello world'
ret = s.replace('world','')
print(s,ret)
```
增加(拼接)+
```
增加(拼接) +
例如：
s = 'hello world'
ret = s.replace('he','he'+'she')
print(s,ret)
```
切片（[起始下标:结束下标:步长]）
```
切片 [起始下标:结束下标:步长]
例如：
s = 'hello world'
ret = s
print(s,ret)
```
查子串 find
关键字 in
```
查字串find(查找的子串,起始下标,结束下标)
例如：
s = 'hello world'
ret = s.find('o') #从左往右找
print(s,ret) #返回字串下标
s = 'hello world'
ret = s.rfind('o') #从右往左找
print(s,ret) #返回字串下标
注意：下标规定从左向右，从0开始，跟遍历方向无关
关键字 in
例如：
s = 'hello world'
a = 'hello'
if a in s:
print("存在")
else:
print("不存在")
注意：只做判断，返回值是布尔类型
```
切割字符串 split
```
切割字符串 split(要切割的子串,切割的个数)
例如：
s = 'hello world'
ret1 = s.split('l')
ret2 = s.split('l',2)
print(s,ret1,ret2) #返回值为列表
```
删除俩端空白 strip
```
删除俩端空白 strip(要删除的子串)
例如：
s = '***hello world***'
ret = s.strip('*')
print(s,ret)
```
长度 len
```
长度 len(字符串)
例如：
s = '***hello world***'
ret = len(s)
print(ret)
```
join将序列中的元素以指定的字符连接生成一个新的字符串
```
str.join(要连接的元素)
例如：
s = ['1','2','3']
ret = '-'.join(s)
print(ret)
```
## **12、列表对象常用方法**
添加append
```
添加 list.append(添加到列表末尾的对象)
例如：
s =
ret = s.append(4) #只可添加一个参数
print(s)
```
添加extend
```
添加 list.extend(元素列表)
例如：
s =
ret = s.extend()
print(s)
```
任意添加 insert
```
任意添加 list.insert(下标, 要插入列表中的对象)
例如：
s =
ret = s.insert(0,5) #只可添加一个参数"?"
print(s)
```
切片添加（[起始下标:结束下标:步长]）
```
切片添加（[起始下标:结束下标:步长]）= [要插入列表中的对象]
例如：
s =
s =
print(s)
```
删除 pop
```
删除 list.pop(要删除元素的下标)
例如：
s =
s.pop(1)
print(s)
```
删除 remove
```
删除 list.remove(要删除的对象)
例如：
s =
s.remove(1)
print(s) #只删除遇到的第一个值
```
修改 下标修改
```
修改 list[下标] = 修改的值
例如：
s =
s = 7
print(s)
```
查找 index
```
查找 list.index()
例如：
s =
a = s.index(1)
print(a)
```
## **13、字典对象常用方法**
增加dic['键'] = 值
```
键值对添加 dic['键'] = 值
例如：
s = {}
s['a'] = 'bc'
print(s)
```
修改dic['键'] = 值
```
键值对修改 dic['键'] = 值
例如：
s = {'a':'cd'}
s['a'] = 'bc'
print(s)
```
删除 del
```
删除 del dic['键']
例如：
s = {'a':'bc','d':'ef'}
del s['a']
print(s)
```
删除 pop
```
删除 dic.pop('键')
例如：
s = {'a':'bc','d':'ef'}
s.pop('a')
print(s)
```
查找 get
```
查找 dic.get('键')
例如：
s = {'a':'bc','d':'ef'}
print(s.get('a')) #查找键对应的值
```
查找 keys
```
查找 dic.keys()
s = {'a':'bc','d':'ef'}
print(s.keys()) #查找所有的键
```
查找 values
```
查找 dic.values()
例如：
s = {'a':'bc','d':'ef'}
print(s.values()) #查找所有的值
```
查找 items
```
查找 dic.items()
例如：
s = {'a':'bc','d':'ef'}
print(s.items()) #查找所有的键值对
```
## **14、集合对象的常用方法**
添加 add
```
添加 set.add('添加的对象')
例如：
s = {1,2,3}
s.add('ab') #添加的对象是无序的，集合是无序的，因此是不能使用下标
print(s)
```
删除 remove
```
删除 set.remove('删除的对象')
s = {1,2,3,'a'}
s.remove('a')
print(s)
```
添加 remove+add
```
添加 先删除后添加组合方式
```
查找 in
```
查找 '查找的元素' in set
例如：
s = {1,2,3,'a'}
print('a' in s) #在 Ture，不在 False
```
个数 len
```
个数 len(set)
例如：
s = {1,2,3,'a'}
print(len(s))
```
空集合
```
创建一个空集合必须用 set() 而不是 { }
```
了解一下数学上的集合：差集（-），并集（｜），交集（&）
这些复合类型的常用方法如过忘记可以使用dir函数进行查看
```
dir([对象、变量、类型])
例如查看列表：
print(dir([]))
```
## **16、函数**
定义
```
命名函数
def 函数名(参数列表)：
函数体
匿名函数
lambda 参数列表:函数体
回调函数
def 函数名(参数列表):
函数名() #内部被调用
函数名(lambda 参数列表)
```
调用
```
命名函数：函数名
匿名函数：
f = lambda x:print(1,2,x)
f(34)
```
返回值
```
通过关键字return 返回数据
def fun(n,m):
return n+m,n-m#函数内没有return或return后没有值的时候，返回None，返回多值的时候，使用逗号隔开，返回值以元组进行返回
print(fun(1,2))
```
参数
```
形参：函数声明时候参数列表中的参数
实参：函数调用时候传递进来的参数
传参方式：
1、位置传参
2、默认传参（从右向左依次传参，不可跳跃）
3、可变传参
例如：
def sum(*args,**kargs):
# args 元组类型 kargs 字典类型
print(args,kargs)
return
sum(1,2,a=4)
4、关键字传参
例如：
print(hellworld, end='') #end就是关键字，顺序可变
传参分类：
1、值传递
2、引用传递 #传递地址 可变类型可以引用传递
```
## **17、模块**
定义
```
.py文件
```
使用
```
导入模块
1、import 模块名（别名）#如果 模块名 as 自己定义的名字，原模块名就不好使了
2、from 模块名（别名）import 函数名或类
3、from 模块名（别名）import *
注意：如果是自己写的模块，引用时需要在同一目录下，如果不在，需要上级目录(包).模块名，在文件夹下有__init__.py,python就会识别为包
使用 模块名(别名).函数名或类
```
__all__
```
__all__ = [''] #内置列表，作用是限制导入的函数或者类，只针对from 模块 import *
```
## **18、文件操作**
打开文件
```
open（）函数用于打开一个文件或者创建一个文件，返回文件对象
打开文件模式
r：只读(默认方式)文件不存在时，会报错
w：只写(文件不存在时，创建文件，文件存在，文件内容被清除)
r+：读写
w+：读写
a：只写(追加写入，只能从文件末尾写入，文件不存在时，创建新文件，文件存在，不会清空文件内容)
a+：读写(追加写入，只能从文件末尾写入)
x：只写(文件不存在时，创建新文件，不存在报错)
x+：只写(文件不存在时，创建新文件，不存在报错)
-------------------------以上以文本方式打开文件---------------------------------------------------
-------------------------以下以二进制方式打开文件--------------------------------------------------
rb：只读(默认方式)文件不存在时，会报错
wb：只写(文件不存在时，创建文件，文件存在，文件内容被清除)
rb+：读写
wb+：读写
ab：只写(追加写入，只能从文件末尾写入，文件不存在时，创建新文件，文件存在，不会清空文件内容)
ab+：读写(追加写入，只能从文件末尾写入)
xb：只写(文件不存在时，创建新文件，不存在报错)
xb+：只写(文件不存在时，创建新文件，不存在报错)
```
读写文件
```
文件名.read()
文件名.readline() #读取一行内容
文件名.read() #全部读取
文件名.write()
文件名.writelines() #全部写入
文件名.write()
```
关闭文件
```
文件名.close()
```
简便操作
```
with关键字
保证文件在打开后能够正确关闭
with open() as f:
f.read()
``` 感谢分享 讲的挺基础 都好厉害 想学的太多了 感谢楼主的总结整理 感谢分享~~~打好基础很重要~ 太深奥了。。。我该从哪里入手。 总结的很好 很不错的基础梳理 谢谢分享
页:
[1]
2