python数据类型，数据操作，函数使用等总结上半篇（有拓展细节）

python学习总结篇（细节）上半篇

一 .
计算机组成：
硬件系统：
1.cpu(中央处理器):处理指令和运算数据
2.内存：存储数据（不是所有数据，）
3 硬盘：永久存储数据

软件系统：
1.系统软件
2.应用软件

二、
Python(免费开源)
网络爬虫，数据分析，人工智能，机器学习，web开发，
自动化运维 ，google(tensorflow) , scikit-learn ，paddle

版本：2.x ，3.x
建议3.5以上

三.
python解释器(编译环境，运行文件)
种类:官方的cpython(c语言开发的) Ipython（基于cpython开发的）

下载-安装-配系统环境

四.
pycharm
社区版 ，专业版

五.
注释（增加代码可读性,解释器不执行注释）
单行注释：以#开头
多行注释：""" xxx “”" , ‘’’ xxx ‘’’
快捷键：ctrl+/

1.变量
存储数据的时候，那个数据在内存地址的名字。
因为外存处理速度比内存慢 ，所以使用变量来快速查找和使用

变量名 = 值 （变量名要满足标识符命名规则，自定义的）

标识符命名规则：
.由数字，字母，下划线组成
.不能以数字开头
.不能使用内置关键字
.严格区分大小写

定义变量例子：person_name = ‘tom’ , tom_age = 1234
使用变量例子 ： print（f“这个人的名字是{person_name}，年龄是{tom_age}”）
输出显示：这个人的名字是tom,年龄是1234

2.Bug
DEbug工具 pycharm集成的调试程序的工具
1.打断点(行号右边空白处单击)，在需要被调试的代码块的第一行打点就可以了
2.调试（逐行调试-step over - F8等方式）

3.数据类型（在编码中可使用type（）函数查看变量数据类型，例 type(person_name)）
数值：整数int，浮点数float
布尔型：TURE ,FALSE
STR字符串，LIST列表 ,TUPLE元组，DICT字典，SET集合

4.输出
格式化输出：
%s 字符串 ，%d有符号的十进制整数 ，%u无符号十进制整数，%f 浮点数等等还有其他建议多看官方文档

例子1：
age = 19
name = ‘tom’
weight = 75.5
print(“今年我的年龄是%d岁” % age )
print(“今年我的名字是%s岁” % name )
print(“今年我的体重是%f岁” % weight)
print(“今年我的体重是%.3f岁” % weight)#保留三位小数输出

输出结果是：
今年我的年龄是19岁
今年我的名字是tom岁
今年我的体重是75.500000岁
今年我的体重是75.500岁

例子2:
#表述输出的整数显示位数，不足以0补全，超出当前位数则原样输出
stuid = 1
stuid2 = 1000
print(“我的学号是%d” %stuid)
print(“我的学号是%03d” %stuid)#输出3位数，不足以0补齐
print(“我的学号是%04d” %stuid)#输出4位数，不足补0
print(“他的学号是%03d” %stuid2)#输出3位数，超出位数原样输出

输出结果是：
我的学号是1
我的学号是001
我的学号是0001
他的学号是1000

例子3：
names = ‘max’
ages = 21
print(‘我的名字是%s,年龄是%d’ % (names,ages))#括号内变量要按照字符串的占位符的顺序
print(‘我的名字是%s,明年的年龄是%d’ % (names,ages+1))

输出结果是：
我的名字是max,年龄是21
我的名字是max,明年的年龄是22

例子4：（这种方式对比上面的比较高效，3.6以上或3.6版本才可用）
names = ‘max’
ages = 21
print(f’我的名字是{names},年龄是{ages}’)
print(f’我的名字是{names},明年的年龄是{ages+1}’)

输出结果是：
我的名字是max,年龄是21
我的名字是max,明年的年龄是22

转义字符：
\n:换行 ，\t:制表符，一个tab键（四个空格键）
例子：
print(‘hello world’)
print(‘hello\nworld’)
print(‘hello \t world’)

输出结果：
hello world
hello
world
hello world

注意：python的print（）函数，它的默认参数结束符 end="\n",所以print是自动换行的，参数end可以改
print函数：
def print(self, *args, sep=’ ‘, end=’\n’, file=None):

5.输入
input(“提示信息”)，常常用变量存储接收到的数据，input接收到的数据类型都是字符串
程序遇到input函数不会继续执行下去，而是等到输入再去执行后面的语句

例子：
a = input(“请输入你的密码：”)
print(a)
print(type(a))

输出结果：
请输入你的密码：1234
1234
<class ‘str’>

6.转换数据类型
int(x) , float(x) ，str(x) , eval()等具体看官方文档

7.python Console(交互式)
######################################################
8.运算符
。算数运算符：+ - x（乘） / (除) %（取余） //（整除） **（指数） （）（提高运算优先级）
。赋值运算符：=（赋值）num = 1 a , b , c = 1,2,3 a = b = 10
。复合赋值运算符：+= -= *= /= //= %= **= (先计算算数运算符 再计算赋值运算符，如果右边是算术表达式 先算右边的算术)
。比较运算符：== != > < >= <=(返回布尔值类型)
。逻辑运算符：and or not (返回布尔值类型)
拓展：数字之间的逻辑运算
and运算符：
只要有一个值为0，则结果为0，否则结果为最后一个非0数据
or运算符：
只有所有值为0结果为0，否则结果为第一个非0数据

###################################################
9.条件语句（注意代码缩进语法，建议四个空格距离）

一，
if 条件：
       条件成立执行的代码
二，
if 条件：
       条件成立执行的代码
else:
      条件不成立执行的代码

三，
if 条件1：
     条件1成立执行的代码
elif 条件2：（elif可以有多个）
    条件2成立执行的代码
else:
     以上条件都不成立执行的代码

四，if嵌套

if 条件1：
       条件1成立执行的代码
       
        if  条件2：
             条件2成立执行的代码

五，三目运算符(三元表达式)
语法：

（条件成立执行的表达式） if （ 条件） else （条件不成立执行的表达式）

例子：

a  = 1 
b = 2 
c = b-a  if  b>a  else  c = b+a   

###########################################
10.循环语句（while,for）

```python
一，
while 条件：
       条件成立执行的代码

二，
break 终止循环 跳出循环体
continue 终止本次循环  进入下一次循环

三，while嵌套
while 条件1：
         执行代码1
         while 条件2：
               执行代码2
         

四，
for 临时变量 in 序列 ：
             重复执行的代码

五，
while 条件：
        条件成立执行的代码
else:
       循环【正常】（break结束的循环属于不正常）结束之后要执行的代码
 

六，
for 临时变量 in 序列 ：
             重复执行的代码
else:
             正常结束执行的代码

########################################
11.
一 .字符串：（数据不可变类型）
单引号 双引号 三引号（支持换行）

二.下标：
string = "qwert"    print(string[1])
输出结果是：w

三.切片：
序列【开始位置下标：结束位置下标：步长】 不包含结束位置下标对应的数据，步长默认为1,都可以使用负数
步长为负数时 ：倒序选取
string = "qwert"     print(string[0:4:1])  #qwer
 
四.字符串查找修改判断（仅包括常用的几个）

查找：
字符串序列.find(子串，开始位置下标，结束位置下标)
字符串序列.index(子串，开始位置下标，结束位置下标)
字符串序列.count(子串，开始位置下标，结束位置下标)
find()：检测某个字串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则返回-1
index():检测某个字串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则报异常
count():检测某个字串是否包含在这个字符串中，如果在返回这个子串出现的次数，否则返回0
 rfind()  rinfex()：从右边开始查找，用法和返回结果与find(),index()一样

修改：
字符串序列.replace(旧子串，新子串，[替换次数])#替换次数如果查出子串出现次数，则替换次数为该子串出现的次数
replace(）：返回一个新的字符串，并不会改变原有字符串

字符串序列.split(分割字符，num)#返回一个列表，列表内不包括分割字符  num表示分割次数

字符或子串.join(多字符串组成的序列)#用一个子串或字符合并字符串，即是将多个字符串合并为一个新的字符串

字符串.lstrip() / rstrip() / strip()  删除字符串 左侧 右侧 两侧的空白字符

判断：
字符串序列.startswith(子串，开始位置下标，结束位置下标)#是否以指定字串开头，返回布尔值
字符串序列.endswith(子串，开始位置下标，结束位置下标)#是否以指定字串结尾，返回布尔值
####################################################
12.
一.列表（数据可变类型）
【数据1，数据2，数据3，....】一次可存储多个数据，且可以为不同数据类型
二.查找
下标：
list_name =【】
函数：
列表序列.index(数据，开始位置下标，结束位置)#返回指定数据所在位置下标，没有就报错
列表序列.count(数据，开始，结束)#统计指定数据在当前列表中出现的次数，没有就返回0
len(列表序列)#访问列表长度，即列表中数据的个数
  
三.判断
in:判断指定数据在某个列表序列，返回布尔值
not in:判断指定数据不在某个列表序列，返回布尔值

四.增加
列表序列.append(数据)#列表结尾追加数据，数据如果是序列，则将这个序列整个为一个单位加进去
列表序列.extend(数据)#列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表
列表序列.insert(位置下标，数据)#指定位置增加数据

五.删除
del name_list 或者 del(name_list)  #删除列表
列表序列.pop(下标)#删除指定下标的数据（默认为最后一个），并返回被删除的数据
列表序列.remove(数据)#移除指定数据
列表序列.clear()#清空列表

六.修改
list[下标] = 数据
列表序列.reverse()#逆序排列
列表序列.sort(key=None,reverse=False/True)#排序: 升序False  降序True

七.复制
列表序列.copy()

八.列表的循环遍历

九.列表嵌套
list_name[[],[],[]]
索引时：list_name[][]

###########################################################
13.元组（数据不可变类型）
tuple = (x,x,x)一个元组可以存储多个数据,数据可以不同类型
tuple = (x,)如果定义的元组只有一个数据，那么这个数据后面也要添加逗号，否则数据类型为唯一的这个数据的数据类型

查找：
tuple.index(数据,开始，结束)
tuple.count(数据，开始，结束)
len(tuple)

注意：元组的数据是不可修改的，但是元组内有列表，那个列表可以修改

############################################################
14.字典（数据可变类型）
dict = { key:value,key:value}#键值对形式
dict = {}  或者 dict = dict() #空字典

增加：
如果key存在则修改key对应的值，不存在则新增
dict[key] = value

删除：
删除字典或者指定的键值对
del(dict)     del dict[key]
清空
dict.clear()

查找：
dict[key] 
dict.get(key,默认值)#如果当前查找的key不存在则返回第二个参数，如果省略第二个参数不写则返回none
dict.keys()#返回一个可迭代对象 返回字典中的key
dict.values()#返回可迭代对象，返回字典中的values
dict.items()#返回可迭代对象，所有键值对，里面的数据是元组，元组数据1是key，元组数据2是value

字典遍历
###########################################################
15.集合(数据不重复，无序)
A = {a,b,c,d}  或者  set{}  #空集合只能用set()方法创建

增加：
A.add(x) #只能增加单一数据，数据序列不行
A.update([x1,x2,x3])#可增加序列，不能增加单一数据
 
删除：
A.remove(x) #删除指定数据 如果不存在报错  
A.disard(x)#删除指定数据 如果不存在不报错
A.pop()# 随机删除某个数据，并且返回这个被删除的数

查找 ：
in  
not  in 
#################################################
16.公共操作
+ 合并（字符串，列表，元组）
* 复制  ( 字符串，列表，元组)
in  元素是否存在  （字符串，列表，元组，字典）
not  in  元素是否不存在 （字符串，列表，元组，字典）

公共方法：
len()  del   del()   max()  min()   range(start,end,step)    
enumerate(可遍历对象，start=0)#返回结果是元组，元组第一个数据是原迭代对象的数据下标	，元组第二个数据是对应的数据


容器类型转换：
tuple(x)序列转为元组
list(x)序列转为列表
set(x)序列转为集合
###############################
17.推导式（化简代码）
列表：用一个表达式创建一个有规律的列表或控制一个有规律的列表
         例子：
              list = [i for i in range(10)]   
              print(list）
              输出结果：【0，1，2，3，4，5，6，7，8，9】
              list = [i for i in range(10)  if i % 2 == 0]#求偶数列表  for+if
              print(list)
              输出结果：【0，2，4，6，8】
              list = [(i,j) for i in range(1,3) for  j  in range(3) ]#for嵌套
              print(list)
              输出结果：【（1，0），（1，1），（1，2），（2，0），（2，1），（2，2）】

字典：快速合并列表为字典或提取字典中目标数据
         例子：
               dict = {i : i**2 for i  in range(1,5)}
               print(dict)#{1:1,2:4,3:9,4:16}

               list1 = ['name','age','gender']
               list2 = ['tom',20,'man']
               dict1 = {list1[i]:list2[i] for i in range(len(list1))}
               print(dict1)#{name:tom,age:20,gender:man}
                        
集合：与上面类似的

总结：
【xx for xx in range()】    {xx : xx for ... in ...}      {xx for xx in ...}
###############################################################
18.函数（可高效实现代码重用，必须先定义再调用）
定义函数：

def  函数名（参数）：
           代码
           .......


调用函数：函数名（参数）

返回值：return x

函数的说明文档：
help(函数名字)  help函数的作用是查看函数的说明

定义函数的说明文档
def 函数名（参数）：
         """ 说明文档"""
             代码
            .......... 
例子 
def sum (a,b):
    """求和函数"""
      return a+b

高级使用说明文档方法
 def sum (a,b):
    """（在这里敲一下键盘回车键）"""
      return a+b

敲完回车键之后：
def sum (a,b):
    """
    （这里还可以写说明文档）
    :param a: 参数1补充说明
    :param b: 参数2补充说明
    :return: 返回值补充说明
    """
    return a+b
  
#################################
函数嵌套调用
一个函数里面又调用另一个函数


变量作用域：
局部变量：定义在函数体内部的变量，只在函数内部生效，临时保存数据，函数调用结束便销毁
全局变量：在函数体内，外都能生效的变量 
函数体内修改全局变量，要先声明它为全局变量：global 全局变量名

函数的返回值 
如果一个函数有两个return  只执行第一个return  原因是因为return可以退出当前函数，导致return下方代码不执行

返回多个值：return a , b  默认是返回一个元组
#######################################################
参数（4种写法）
位置参数：调用函数时根据函数定义的参数位置来传递参数（形参和实参的顺序，个数必须一致）

关键字参数：通过 键=值 形式加以指定（如果有位置参数，那位置参数必须放在关键字参数前面）

缺省参数：设置默认值，调用时可不传参  

不定长参数：不设定个数的参数，不确定参数个数，可变参数   
*args是元组类型（包裹位置传递）
def  function(*args):
          代码
          print(args)
          ......
function(1,2,3)#(1,2,3)

*kwargs是字典类型（包裹关键字传递）	
def function2(**kwargs):
          代码
          print(kwargs)
          .......
function2(a = 1,b = 2)#{'a':1,'b':2}

############################################
交换变量值
a,b = 1,2
a,b = b,a
print(a,b)#2 1


引用：在python中，值是靠引用来传递来的


可变类型：列表 字典 集合
不可变：整型 浮点型  字符串  元组
############################