#python数据类型

python的数据类型： list,dict,tuple,set,String,Number,Boolean,None

其中可变的的有：list，dict

不可变的：其他都不可变

字符串的重要性

操作文本或者数据可是件大事。如果不相信，就仔细看看当今计算机都在做什么工作：
文字处理、网页表单的填写、来自数据库
转储的信息流、股票报价、新闻等等，而且这个清单还会不断增长。

什么是字符串？

是由数字、字母、下划线组成的一串文字。它是编程语言中表示文本的数据类型。
简单的说就是用单引号或者双引号括起来的文本。

字符串的处理

创建字符串

str1 = "hi，Look at this girl, she's really beautiful"
print(str1)

字符串的连接

str2 = "i love her"
str3 = str1 + str2
print("str3=",str3)

字符串的复制

str4 = str2 * 3
print(str4)

字符串的长度

print(len("beautiful"))

count(str[,start][,end])

返回字符串中某个单词出现的次数，可以指定一个范围，默认从头到尾
str5 = "hi，Look at this girl, she's really beautiful"
print(str5.count("girl", 16,len(str5) ))

find(str[, start][,end])

从左向右检测str字符串是否包含在字符串中，可以指定范围，默认从头到尾。得到的是第一次出现的开始下标，没有返回-1
print(str5.find("girl"))
print(str5.find("one"))

split(str="", num)

以str为分隔符截取字符串,指定num，则仅截取num个字符串
str6 = "hi，Look at this girl, she's really beautiful"
list7 = str6.split(" ")
print(list7)

join(seq) 以指定的字符串分隔符，将seq中的所有元素组合成一个字符串

print(list7)
str8 = "#".join(list7)
str9 = " ".join(list7)
print(str8)
print(str9)

list列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型

list10 = [1,2,3,4,5,]
print(list10)

list11 = [1,2,3,"hello",1,2,3]
print(list11)

列表元素的访问，注意不要越界了（下标超出可表示的范围）

list12 = [1,2,3,"hello",1,2,3]
print(list12[3])

print(list13[7])

列表的替换

list12[3] = "beautiful girl"
print(list12)

列表的组合和string一样

list13 = [1,2,3]
list14 = [4,5,6]
list15 = list13 + list14
print(list15)

列表的重复也和string一样

list16 = list13 * 3
print(list16)

判断元素是否在列表中,在返回True，不在False

list17 = [1,2,3,"hello",1,2,3]
print("hello" in list17)

列表的截取,如果超出边界，没事

list18 = [1,2,3,"hello",1,2,3]
print(list18[3:6])

二维列表

list19 = [[1,2],[3,4],[5,6]]
print(list19[1][1])

列表的append方法,在末尾添加元素

list20 = [1,2,3]
list20.append(1)
print(list20)

list21 = [1,2,3,4]
list21.append([4,5])
print(list21)

list22 = [1,2,3]
list22.extend([4,5,6])
print(list22)

列表的insert方法

list23 = [1,2,"hello",1,2]
list23.insert(3,"girl")
print(list23)

list24 = [1,2,"hello",1,2]
list24.insert(3,[3,4])
print(list24)

列表的删除

第一种：pop删除

pop(x=list[-1])
移除列表中指定下标处的元素（默认移除最后一个元素）,并返回删除的数据
list25 = [1,2,3,4,5]
list25.pop()
list25.pop(2)
print(list25.pop(1))
print(list25)

第二种：remove删除

remove 移除列表中的某个元素第一个匹配的结果
list26 = [1,2,3,4,5,5,5]
list26.remove(5)
print(list26)

第三种：del删除，根据索引，删除元素

list27 = [1,2,3,4,5]
del(list27[4])
print(list27)

第四种：clear()方法,删除整个列表中的元素

list28 = [1,2,3,4,5]
list28.clear()
print(list28)

从列表中找出某个值第一个匹配的索引值

list29 = [1,2,3,4,5,6,7,8,9]
index29 = list29.index(3)
print(index29)

列表中元素个数

list30 = [1,2,3,4,5]
print(len(list30))

列表的Max、min方法

list31 = [1,2,3,4,5]
print(max(list31))
print(min(list31))

列表的count方法

list32 = [1,1,1,2,3,4,5]
print(list32.count(1))

列表的排序

list33 = [1,3,5,7,2,4,6,8,1,1.1]
list33.sort()
print(list33)

list34 = [1,3,5,7,2,4,6,8,1,1.1]
list34.reverse()
print(list34)

浅拷贝和深拷贝

1，深浅拷贝都是对源对象的复制，占用不同的内存空间。
2，不可变类型的对象，对于深浅拷贝毫无影响，最终的地址值和值都是相等的。
3，可变类型：
=浅拷贝： 值相等，地址相等
copy浅拷贝：值相等，地址不相等
deepcopy深拷贝：值相等，地址不相等

浅拷贝： = 的浅拷贝

list35 = [1,2,3,4,5]
list36 = list35
print(list35)
print(list36)
print(id(list35))
print(id(list36))

copy的浅拷贝

list37 = [1,2,3,4,5]
list38 = list37.copy()
print(list37)
print(list38)
print(id(list37))
print(id(list38))

深度拷贝

import copy
list39 = [1,2,3,4,5]
list40 = copy.deepcopy(list39)
print(list39)
print(list40)
print(id(list39))
print(id(list40))

浅拷贝和深拷贝的区别：

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。
深拷贝(deepcopy)：copy模块的deepcopy方法，完全拷贝了父对象及其子对象。
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用

a.append(5)

c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象

print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )

列表的转化

元组转列表

list41 = list((1,2,3,4,5))
print(list41)

列表转元组

tuple42 = tuple([1,2,3,4,5])
print(tuple42)

列表的去重

list43 = [1,1,2,3,4,5]
set(list43)

for i in list43:
print(i)

dict字典

字典是另一种可变容器模型。
概述:
使用键-值(key-value)存储，中间用冒号：分割，具有极快的查找速度

注意：字典是无序的

key的特性：

1、字典中的key必须唯一
2、key必须是不可变对象
3、字符串、整数等都是不可变的，可以作为key
4、list是可变的，不能作为key

dict44 = {"Bili":"北京","twodog":"shenzhen"}
print(dict44)

元素的访问

获取：字典名[key]
print(dict44["Bili"])
print(dict44.get("Bili"))

key_name = dict44.get("twodog")
if key_name == None:
print("没有")
else:
print("有")

补充，拓展

python中的命名规范

不要用系统的关键词

import keyword
print(keyword.kwlist)

模块

模块尽量使用小写命名，首字母保持小写，尽量不要用下划线
import copy

类名

ThisClass

函数

函数名一律小写，如果有多个单词，用下划线隔开
def post():
pass

变量名

变量名尽量小写, 如有多个单词，用下划线隔开
django中manage.py文件中
if name == 'main':
count = 0
student_name = "twodog"

当.py文件被直接运行时，if name == 'main'之下的代码块将被运行；
当.py文件以模块形式被导入时，if name == 'main'之下的代码块不被运行。

对于很多编程语言来说，程序都必须要有一个入口，比如C，C++，以及完全面向对象的编程语言Java，C等。
如果你接触过这些语言，对于程序入口这个概念应该很好理解，C，C++都需要有一个main函数作为程序的入口，
也就是程序的运行会从main函数开始。同样，Java，C必须要有一个包含Main方法的主类，作为程序入口。
而Python则不同，它属于脚本语言，不像编译型语言那样先将程序编译成二进制再运行，而是动态的逐行解释运行。
也就是从脚本第一行开始运行，没有统一的入口。

一个Python源码文件（.py）除了可以被直接运行外，还可以作为模块（也就是库），被其他.py文件导入。
不管是直接运行还是被导入，.py文件的最顶层代码都会被运行（Python用缩进来区分代码层次），
而当一个.py文件作为模块被导入时，我们可能不希望一部分代码被运行

常量名

全大写，如果有多个单词用下划线分隔
SOCIAL_AUTH_WEIBO_KEY = '123456'
SOCIAL_AUTH_WEIBO_SECRET = '12345678901234567890'

字典的添加

dict45 = {"Bili":"北京","twodog":"shenzhen"}
dict45["yellowhair"] = "shenzhen"
print(dict45)

字典的修改

因为一个key对应一个value,所以，多次对一个key的value赋值，其实就是修改值
dict1["lilei"] = 80
dict45["twodog"] = "changsha"
print(dict45)

删除

dict45.pop("yellowhair")
print(dict45)

遍历

遍历键

for key in dict45:
print(key, dict45[key])

遍历值

for value in dict45.values():
print(value)

遍历字典项

for k, v in dict45.items():
print(k, v)

遍历字典健值

for k, v in enumerate(dict45):
print(k, v)

和list比较

1、查找和插入的速度极快，不会随着key-value的增加而变慢
2、需要占用大量的内存，内存浪费多

list

1、查找和插入的速度随着数据量的增多而减慢
2、占用空间小，浪费内存少

tuple元组

tuple
本质：是一种有序集合
特点：
1、与列表非常相似
2、一旦初始化就不能修改
3、使用小括号

创建一个元组，如果只有一个元素，需要加逗号

tuple46 = (1,)
print(tuple46)

tuple47 = (1,2,3,"hello",1,2,3)
print(tuple47)

tuple48 = (1,2,3,4,5)
print(tuple48[0])

print(tuple48[-1])

超出边界

print(tuple48[-6])

修改元组

tuple49 = (1,2,3,4,5)
tuple49[0] = 10
print(tuple49)

tuple50 = (1,2,3,[4,5])
tuple50[-1][0] = 100
print(tuple50)

删除元组

tuple51 = (1,2,3,4,5)
del tuple51
print(tuple51)

元组的操作

tuple52 = (1,2,3)
tuple53 = (4,5,6)
print(tuple52+tuple53)

判断元素是否在元组中

tuple54 = (1,2,3,4,5)
print(2 in tuple54)

元组的截取,前闭后开区间

tuple55 = (1,2,3,4,5)
tuple56 = tuple55[1:3]
print(tuple56)

tuple57 = tuple55[:4]
tuple58 = tuple55[3:]

二维元组，元素是一维元组的元组

tuple59 = ((1,2),(3,4),(5,6),(7,8,9))
print(tuple59)

print(tuple59[3][2])

返回元组中的个数

tuple60 = (1,2,3,4,5)
print(len(tuple60))

返回元组中的最大值和最小值

tuple61 = (1,2,3,4,5)
print(max(tuple61))
print(min(tuple61))

元组的遍历

tuple62 = (1,2,3,4,5)
for i in tuple62:
print(i)

set集合

set:类似dict，是一组key的集合，不存储value
本质：无序和无重复元素的集合
创建set需要一个list或者tuple或者dict作为输入集合
重复元素在set中会自动被过滤
set63 = set([1,2,3,4,5,1,2,3,4,5])
print(set63)
set64 = set((1,2,3,1,2,3))
print(set64)
set65 = set({"Bili":"beijing", "twodog":"shenzhen"})
print(set65)

添加

set66 = set([1,2,3,4,5])
set66.add(6)
print(set66)
set66.add((7,8,9))
print(set66)

删除,删除的是值

set67 = set([1,2,3,4,5])
set67.remove(3)
print(set67)

遍历

set68 = ([1,2,3,4,5])
for i in set68:
print(i)

for index, data in enumerate(set68):
print(index, data)

set69 = set([1,2,3,4,5])
set70 = set([2,3,4,7,8])

交集

set71 = set69 & set70
print(set71)
print(type(set71))

并集

set72 = set69 | set70
print(set72)
print(type(set72))

number数字

分类：整数、浮点数、复数，其中整数包括正整数和负整数，和数学中的写法一样

数字类型的转换

什么是库？库就是封装了一些方法的函数

import math
import random

f1 = 1.1
f2 = 2
print(f1+f2)

数字类型转换

print(int(2.9))
2

print(float(1))
print(int("12345"))
print(float("12.345"))

如果有其他无用字符会报错

print(int("abc"))
print(int("123abc"))

只有作为正负号才有意义

print(int("+12345"))

print(int("12+3"))

print(int("-12345"))

print(int("12-3"))

数学功能

返回数字的绝对值

a1 = -10
a2 = abs(a1)
print(a2)

比较两个数的大小

a3 = 100
a4 = 9
print((a3>a4)-(a3<a4))

返回给定参数的最大值

print(max(1,2,3,4,5,6,7,8))

返回给定参数的最小值

print(min(1,2,3,4,5,6,7,8))

求x的y次方 2^5

print(pow(2, 5))

round(x[,n])返回浮点数x的四舍五入的值，如果给出n值，则代表舍入到小数点后n位

print(round(3.141592654))
print(round(3.141592654))
print(round(3.141592654, 2))
print(round(3.141592654, 1))

向上取整

print(math.ceil(1.1))
print(math.ceil(1.9))

向下取整

print(math.floor(1.1))
print(math.floor(1.9))

返回整数部分与小数部分

print(math.modf(2.3))

开方

print(math.sqrt(9))

随机数

1从序列的元素中随机挑选一个元素

print(random.choice([1,3,5,7,9]))
print(random.choice(range(5)))#range(5) == [0,1,2,3,4]
print(random.choice("girl"))#"sunck" == ["s","u","n","c","k"]

产生一个1~100之间的随机数

r1 = random.choice(range(10)) + 1
print(r1)

从指定范围内，按指定的基数递增的集合中选取一个随机数

random.randrange([start,] stop[, step])

start--指定范围的开始值，包含在范围内，默认是0

stop--指定范围的结束之，不包含在范围内

step--指定的递增基数，默认是1

print(random.randrange(1, 100, 2))

从0-99选取一个随机数

print(random.randrange(100))

随机生产[0,1)之间的数(浮点数)

print(random.random())

list = [1,2,3,4,5]

将序列的所有元素随机排序

random.shuffle(list)
print(list)

随机生产一个实数，他在[3,9]范围

print(random.uniform(3,9))