计算机基础
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）
元素类型任意[1,'',{},[],()]
可变类型
字典（Dict）
一组键值对：{键：值}
{1:56,2:'hello','name':'Tom'}
可变类型
注意：键必须是不可变类型，值是任意类型，键是不可重复类型，一般字符串作键
如果出现相同键，后面的会覆盖前面的
{}表示：空字典
如：d={} #d是字典类型，不是集合
元组（Tuple）
元素类型任意(1,'',[],{})
不可变类型
集合（Set）
可变类型但元素必须是不可变类型
{1,2,3} #正确
{1,2,[1,2]} #错误
常用于数学运算
元素是不可重复的，可以用来去重即类型转换
如：a=[1,1,2,2]
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[0] #删除字符串中的
print(s)
输出错误
错误信息：
del s[0]
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[1:2]
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 = [1,2,3]
ret = s.append(4) #只可添加一个参数
print(s)
添加extend
添加 list.extend(元素列表)
例如：
s = [1,2,3]
ret = s.extend([4,5,6])
print(s)
任意添加 insert
任意添加 list.insert(下标, 要插入列表中的对象)
例如：
s = [1,2,3]
ret = s.insert(0,5) #只可添加一个参数"?"
print(s)
切片添加（[起始下标:结束下标:步长]）
切片添加（[起始下标:结束下标:步长]）= [要插入列表中的对象]
例如：
s = [1,2,3]
s[0:0] = [4,23,]
print(s)
删除 pop
删除 list.pop(要删除元素的下标)
例如：
s = [1,2,3]
s.pop(1)
print(s)
删除 remove
删除 list.remove(要删除的对象)
例如：
s = [1,2,3，1]
s.remove(1)
print(s) #只删除遇到的第一个值
修改 下标修改
修改 list[下标] = 修改的值
例如：
s = [1,2,3,1]
s[3] = 7
print(s)
查找 index
查找 list.index()
例如：
s = [1,2,3,1]
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()
[复制链接]
发表于 2022-4-2 14:26
