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()