Python入门之数据类型详解及函数

一 . 数据类型

常见的数据类型分为三种:

数字型:int,bool,float
复数型:科研
非数字型:字符串,列表,元组,字典

对于上面的数据类型还可以根据是否可变分为两类:

可变:列表,字典(重新赋值内存地址不会变)
不可变:数字类型,字符串,元组(重新赋值内存地址会变)

1. 字符串

字符串时我们最常见的数据类型,那么它有什么用呢?

(1) . 定义:name=“string”,当然也可以用单引号来定义
也可以将字符串里面的一个字符拿出来print（name[4]）,字符串也可以遍历for循环

(2) . 常见的字符串方法:

(1) . name=“thisistest”
(2) . len(name) //统计字符串的长度
(3) . name.count(“is”) //统计is出现的次数,没有的话报错
(4) . name.index(“is”) //判断is出现的位置,没有的话报错

(5) . is判断类型方法

(6) . 替换：
name.replease(“jiu”,“xin”)
会生成一个新的，但是不覆盖，如果想要覆盖则要重新赋值
name.find方法：招不到返回值为-1
name.index方法：招不到会报错

(7) . 大小写:
第一个大写.capitalize()
每个字符串单词首字母：title()
所有大写换位小写:lower
小写换位大写：upper()
翻转里面的大小写：swapcase（）

(8) . 文本对齐:
name.ljust（）左对齐
nem.rjest（）
nema.center（10（字符），” 中文加空格“）中心对

(9) . 去除空白字符:
name.lstrip()
name.rstrip()

(10) . 拆分:
name.split（）拆
name.join（）连

(11) . 切分倒叙:
str[-1::-1]:逆序输出
str[::-1]:逆序输出
取完整的字符串就可以啊开头结尾都省略

(12）判断开头
name.startswith(‘s’)判断是不是以s开头
name.endwith(‘s’)以s结尾

(3) . 公共方法
内置函数
1、len（）函数：元素格式
2、del（）删除变量：del a[2] del(a[3])
3、max（）元素最大值，
4、min（）元素最小值：对于字典的话，之对于key不对于值
5、cmp（）比较 “1” 》 “3”数字字符串，字典不能比较大小python3没有

2 . 字典

字典存储无序的对象集合
列表【】 索引来找
元组（） 索引来找
字典 {} 键值来找

(1) . 定义
xiaoming={“key”：value}
print（xiaoming）

(2)、取值

print(xiaoming=[“key”]) //指定的key一点更要存在
(3)、增加
xiaoming[“age”] = 18 //如果key存在，重新赋值，不存在，创建新的键值
(4)、删除
xiaoming.pop(“key”) //删除键值

(5)、字典的统计键值数量
print（len（xiaoming））

(6)、合并字典
tem={”dd“：dd}
xiaomin.update（tem）//如果合并的字典有意境存在的键值，会覆盖

(7)、清空字典
xiaoming.clean（）

(8)、遍历字典for

for i in xiaoming:  //i是每一次循环的key
    print(”%k    %s“%（k，xiaoming（k））)

(8)、字典和列表的应用
字典：列表里面是字典

list=[
	{
    
    “name”：张三，
	“qq”，123
	”phone“：110}，
	{
    
    “name”：李四，
	“qq”，133
	”phone“：410}，}
]

for i in list：# 遍历列表里面的字典
    peint（i）

(10)、key只能是不可变类型（数字）
int，bool，float，complex，long,字符串,元组
不可以时可变的列表,字典

3 . 元组

(1) . 定义
tupe =（1，2，3）
差别：不可以修改任何数据，不可增删改
保存不同类型的数据
索引从0开始

(2) . 查看数据
tupe[1] //第二个数据
创建一个空元组
tupe=()
创建一个只有一个数值的元组
tupe =（1，）元组里面有一个元素必须要用逗号

(3) . 元组的常用操作

len（tupe）//统计元组的数据
tupe.count(”zan“) //统计tupe中出现的次数
tuoe.index(“shuju”) //查看数据的索引


(4) . 遍历元组

for i in tupe:
print(i)

(5) . 格式字符串
让列表不被修改
元组和列表的转换：
list=[1,2,3,4]
new_tup=tuple(list)//变为元组
new_list-list(tup) //变为列表

4. 列表

(1) . 定义
存储多个数据
list =【1，2】
索引从0开始
print（list[1]） //第二个元素

(2) . 列表常用操作

(1). 取值：
 print(list[x])
(2) . 想知道元素在那个索引里面：
 list.index()//必须是列表里面的数据
(3) . 修改列表指定数据
 list[x]=“ddd” //修改x索引的数字为ddd，必须是所在的索引列表中添加数据
(4) . 末尾添加
 list.append(“wangxiaoer”)self;object//添加
(5) . 指定位置添加
 list.insert（1，“xxx”）
(6) . 插入列表,将新列表添加到旧列表的后面
 temp_list=[]
 list.extend(temp_list)
(7) . 删除：
 list.remove("")//删除指定的数据//如果有两个的话会删除第二个，没有的话就会报错
(8).清空整个列表
 list.clear（）
(9) . 删除指定位置
 list.pop（x）//不加参数，会将末尾一个元素删除，删除索引x的数据
(10) . 内存中删除
 del list[1]//删除索引1的数据，从内存中删除如果用del删除，后面不能再使用这个变量了
(11) . 统计：
 list_len=len(list)//列表list元素
 list.count("")//统计数据出现了多少次
 Ctrl+Q：查看方法的详细信息
(12) . 排序：
 list.sort()//升序排序，英文字母也排序，数字也排序
 list.sort（reverse=True）//降序排列
 逆序：
 list.reverse()//倒叙输出
(13) . 列表的循环遍历：
 list=[]
 迭代遍历for
 for i in list:
   print(i)

5 . 运算符

-------------------------------------------------------------------------------------------------------------------------
(1) . 切片
有索引值可以切片
【s，1，2，3】【1：3】列表
（s，1，2，3）【1：3】元组
字典不可以，是无序的，没有索引值


(2) . *
（）*6
【】*6
{}*6不支持称号，key唯一的


(3) . +
“”+“”
() +()
[] + [] /llistextend([2,3]) /llist.append([2,8])会当成一个元素

(4) . in
是否在元素在
“a”in “qwdea”
“a”not in “qazxsw”
字典的话，只会检测key

二 . 函数

具有独立功能的代码组成的一个功能模块

1 . 函数定义

def name():
	jjjjj

name() # 调用函数,如果函数有返回值要有一个变量来接受返回值

如果这个函数在另外一个包里面,要先导入包import package
对于导入包的函数调用的时候要package.name()

2 . 函数参数

(1) . 形式参数,实际参数
def sum (a,b) //对于函数来说ab就是形式参数
sum(2,3) //2和3 实际参数


(2) . 传递多个参数
元组,字典(当然返回值也是元组和字典)
字典:def sum(**kwargs)
元组:def sum(*arg)
如果不想用*args也可以,但是传参数的话就要多加一个()

(3) . 局部变量,全局变量
局部变量:在函数中定义,除了函数就不存在
全局变量:在哪都可以用
怎么在函数内部修改全局变量呢?
global name=“djidj”

(4) . 拆包
拆包： 将元组变量或者字典变量传递到函数里面叫做拆包
在元组变量前加*，字典变量前加**

def xx(num,*nums,**numss): # 定义函数
	wwww



list=(1,2,3,4) # 定义变量
dir={
    
    "name":123,"age":345}
ll="sdfsdf"

xx(ll,*list,**dir) # 调用函数
传递参数要给其加*,不然会出错

(4) . 缺省参数
一个默认的参数,如果不指定会用默认的数,例如列表的sort方法,默认是正序

1、定义:def xxx（name，gender=True）,默认为True
2、缺省参数的注意事项
（1）其他参数应该放在缺省参数的前面
（2）调用具有多个缺省参数，要指明

(5) . 递归函数
顺代码相同的，只是针对参数不同，处理结果不同，当参数满足一个条件，函数不在执行，称之为函数的出口

def name(num)
	if num == 1
	return 
	name(num-1)
	xxxxxx

(6) . 函数内部给全局变量赋值

类型	影响	结果
可变类型(列表，字典)	影响	全局变量的值会因为函数内部变话而变化
不可变类型(数字类型,字符串,元组)	不影响	不会变化

函数内部赋值，不会影响到外部的不可变类型变量
函数内部赋值，会影响可变类型的变量 ，可变类型，列表，字典
为什么？
因为不可变类型会重新找一个内存地址来方新的变量
而可变类型，只会在后面添加新的数据，内存地址不会变


(7) . +=
对于+=来说时:n+=1
n=n+1
对于函数里面的数字不影响
但是对于列表来说用+=就是调用了list.extend方法,函数外面的列表也会发生变化(他是可变类型的)

3 . 返回值

(1) . 函数返回值
在调用这类函数的时候,要有一个变量来接受函数的返回值,然后输出.
函数的返回值也可以是元组

def sum(a,b)
	s=a+b
	return s

result=sum(2,3)
print(result)

(2) . 多个返回值
num1,num2=message() //函数

三 . 扩展

1. 交换两个数

(1) 三个变量来是想
(2) 比如
a,b
a=a+b
b=a-b
a=a-b
(3) Python独有方法
a,b=(b,a)
a.b=b,a
虽然等号右边没有括号,但是还是元组,只不过省略了括号

2 . 哈希

提取数据的特征码
但是只能提取不可变的特征码
可变类型均不可哈希,可变列表和字典不可提取

3 . 集合

per={1，2，3，4}
set={1，2，3，4}
pert={‘www’，‘eee’}
集合会自动去重
x in pert判断x是否在pert里面
集合间的运算
交集，并集，补集
a&b a和b都有的
a ^ b交集后的补给
移除元素
a.remove(‘ss’)
a.discard(‘sss’)如果没有不会报错
s.pop（）随机删除元素
计算集合个数
len（s）
清空元素
s.clear()
复制一个集合b
b=a.copy