首页 > 代码库 > Python漫漫艰辛路之day1
Python漫漫艰辛路之day1
今天做的内容就是从头整理笔记，方便以后调用查看。
变量
a = 1 表示先从内存中申请一块内存空间。把数据1创建出来。这个“1“也可以称为对象。
变量命名注意事项：
变量名只能是字母、数字或下划线的任意组合
变量名的第一个字符不能是数字
关键字不能声明为变量名
变量名一定要有含义。
变量名不要写拼音和中文。
永远都不改变的量称为常量，在python中要大写。对象可以通过一个点去调用方法。
数据类型
所有的数据类型一定会划分成两种：
一种是可变数据类型：列表，字典
另一种是不可变数据类型： 整型，浮点型，元组，字符串
一旦创建就不能被修改，比如a=1表示给内存空间里开辟了一块空间用来存1的值，然后又a=2，并不是把1值覆盖了，而是又重新创建了一个数据对象，之前的数据对象并没有变，这就叫不可变数据类型。
不同的类型占位也不一样。内存的空间都是有限的，比如10/3，它的结果能无限循环小数，我们不可能把这具结果存到内存里去，不然多大的内存都不够用了，所以我们一定要把这个内存最大使用化。比如整型，假如占一个字节，内存就分配给它一个字节，固定好这个关系，用不完没关系，如果超了就使用另外一个类型。
1、整型int
python3.X版本里，数字如果在整型的范围，它会给你一个固定的字节数，如果超过了，它会识别这个数字的大小，自动给你补上字节数
2、浮点型float 、 doble
和整型一样，只是整型表示整数，浮点型表示小数，浮点型还包括科学计数法，
如：1.23e-4
float 和 doble的区别在于它们后面的小数精确度不一样。doble后面的小数精度非常高。
3、布尔值 True 、 False
最大的用处不是用来运算，而是用于条件判断。
True 代表1， False代表0
4、字符串 string 包含字符串、元组、列表、字典
字符串都是通过引号引起来的。创建字符串都有两种方式：
一种是最直接的通过某种表达式来创建
如： s = “william”、 l = [1,2,3,4]
另一种是通过关键字来创建。
如：s1 = str(william ) 、l =list(1,2,3,4)
(1)字符串
注意事项：一个字符串里如果有多个引号，可以双引号、单引号交替，也可以和反斜杆进行转义。
例：s = “Let’s go”
s = ‘Let\’s go’
若一个字符串中有多个转义符，为了看起来不麻烦，则在字符串前加上r即可全部转义，如：
s = r“\fade\\\sfe\sfsfa”
对字符串进行操作：
一、查操作:
切片操作
s1 = ‘hello world‘
print(s1[1:4]) # 按下标位顺序取第1至第3位的字符，顾首不顾尾 #输出结果：ell
print(s1[1:4:2]) # 按步长取，不加步长默认是1 #输出结果：el
print(s1[-1]) # 取最后一个字符。#输出结果：d
print(s1[:]) # 取出全部字符。#输出结果：hello world
print(s1[:8]) # 取出下标位顺序从0开始取到第7位 #输出结果：hello wo
print(s1[1:-1]) # 取出下标位1至倒数第二位#输出结果：ello worl
print(s1[1:]) # 取出下标位1至最后所有的字符。# 输出结果：ello world
print(s1[-3:-1]) # 取出下标位倒数第3位至倒数第2位。# 输出结果：rl
二、字符串的方法
对象.方法（参数）
1、strip(参数 )
把字符串开头和结尾处的空格、换行符\n去掉。
（1）s = ‘ hello\nworld‘.strip()
print(s)
# 输出结果：hello
world
注意：只去掉开头和结尾的空格和\n，字符串中间的空格和\n不会被去掉。
（2）s1 = ‘**hello\nworld\n***‘.strip("*")
print(s1)
# 输出结果：hello
world
注意：strip(“*”)括号中的*，表示去除带*号的符号
（3）字符串后面可以接多个.strip( )
2、拼接方法：+和join
（1） +
s = ‘hello‘+‘world‘
print(s)
# 输出结果：
helloworld
这种方式效率过低，占用内存空间。只有在拼接次数少的情况下用效率高。
（2）”参数”. join（[ “字符串”，“字符串”]）
print("*".join(["I","am","world!"]))
# 输出结果：
I*am*world!
[ ]中一定得是字符串对象。
这种方式效率高，只申请一次内存空间就能拼接起来，推荐使用此方法。
3、切片方法split
”字符串”.split(“参数” )
将一个字符串以指定的分割符切片成若干个列表的
（1）s = "hello world".split(" ")
print(s)
# 输出结果：
[‘hello‘,‘world‘]
# 以空格为分隔符，将"hello world"分隔成一个列表。
（2）s = "hello world".split("e")
print(s)
# 输出结果：
[‘h‘,‘llo world‘]
# 以字符e为分隔符，将"hello world"分隔成一个列表。
（3）s = ‘hello world ‘.split("l",1)
print(s)
# 输出结果：
[‘he‘ , ‘lo world‘]
# 表示以字符"l"为分隔符，将"hello world"分隔成了一个列表，后面的1表示分隔字符"l"一次
4、查找字符方法find和index
1、find方法
“字符串”.find(“查找的字符”) 最终显示要查的字符的位置
（1） print("hello world".find("e"))
# 输出结果：
1
# 表示"e"在字符串中第1个位置
（2）print("hello world".find("l"))
# 输出结果：
2
# 表示"l"在字符串中从左至右数第1个字符"l"所在的位置。
（3）print("hello world".rfind("l"))
# 输出结果：
9
# 表示在字符串中从右至左数的第一个字符"l"所在的位置。
5、替换方法 replace
“字符串”.replace(“要替换的旧内容”，“新内容”)
（1）print("hello world".replace("world","Python"))
#输出结果：
hello Python
# 这种方式叫做完全匹配，只要匹配的内容中不一样，就会报错。
replace没有返回值，对字符串这种不可变类型进行操作一定是返回一个新的字符串类型，而之前的s不会发生任何变化。
6、format() 方法，格式化出
通过键值对形式关键字传参，而且可以随意换位置也不影响。（推荐方法）
（1）s = ‘my name is {name}, I am {age} years old‘
print(s.format(name = "william", age = "29"))
#输出结果：
my name is william, I am 29 years old
(2) print(‘hello {0}, his age is {1}‘.format("alex",34))
#输出结果：
hello alex,his age is 34
7、% : 格式化输出
（1）%s：给字符串占位
1） print("hello %s"%"sb")
#输出结果：
hello sb
2）print("hello %s,%s"%("sb","egon"))
#输出结果：
hello sb,egon
# 替换多个字符串时，小括号里的字符串一一对应
（2）%d : 给整型占位
print("hello %s,his age is %d"%("sb",35))
#输出结果：
hello sb, his age is 35
这里的%d换成%s也没有问题，就是把“35”这个数字转换成了字符形式。不是特别需要时，建议用%s，不容易出错，。
（3）%f：给浮点型占位。
print("hello %s,his age is %f"%("sb",35))
#输出结果：
hello sb,his age is 35.000000
三、列表操作
它很像生活中的清单。清单中每样物品都是一个并列的方式，而且都有一个索引（第几行）
1、列表的创建：
（1）直接通过{ }创建
变量名 = [参数，参数，“参数”，｛｝ ]，其中参数可以放整型，可以放字符串，也可以嵌套列表、字典、元组。
例：
l = [“hello”,[4,5],{“name”:”egon”}]
概念：字符串、元组、列表等都叫作可迭代对象。那什么叫作可迭代对象呢？能够进行for循环的都是可迭代对象。
（2）通过list赋予变量名来创建列表：
例：
l2 = list( [1,2,3] ) # 其中[ ]在里面表示是一个序列，并不是列表。
l2 = list((1,2,3)) # 其中（）在里面也只是一个序列，并不是元组。
通过list创建列表中，小括号里的 [ ] 和（）只是组织元素通过list称为一个整体之后对它进行一个实例化。
2、对列表进行增删改查
实际工作中用得最多的就是对列表进行增删改查，比字符串的操作用得多。
（1）l3 = [1,23,3,43,5345,564,656,77] # 顾首不顾尾。
print(l3[-2:])
#输出结果：
[656,77]
（2）列表的增加
.append( ) 添加元素到末尾，且只能添加一个元素。打印时返回空值。
l3 = [1,23,3,43,5345,564,656,77]
l3.append("yuan") # 在列表l3后面的添加“yuan”字符
print(l3)
#输出结果：
[1,23,3,43,5345,564,656,77,"yuan"]
（3）.extend( ) 添加多个元素到末尾。
l3 = [1,23,3,43,5345,564,656,77]
l3.extend([7,8])
print(l3)
#输出结果：
[1,23,3,43,5345,564,656,77,[7,8]]
（3）.insert( ) 添加元素到指定位置。
l3 = [1,23,3,43,5345,564,656,77]
l3.insert(2,"jjj") # 表示在位置2的位置插入‘jjj‘
print(l3)
#输出结果：
[1,23,‘jjj‘,[‘hello‘,334],656,77]
3、列表的删除：
（1）按位置删除pop
.pop（）按索引值删除列表中的元素，括号内不加参数表示默认删除列表中的最后一个。在小括号中加入数字删除表示删除指定索引值的元素。
pop有返回值，返回删掉的那个值的返回值。
（2）按具体内容删除remove
.remove( ) 不知道列表中的元素的位置，但是知道元素的内容。
（3）del删除
不但能能过索引删除列表数据，也可以通内容删除数据，只要能从列表中取出的数据都能删除。还能删除所有的数据。
del不但能删列表中的元素，还能把列表删了。
( 4 ) 列表的改——赋值操作。
通过切片找到要改的数据
4、统计列表中指定元素的个数 .count( ) 括号中输入要统计的元素名称。
四、字典
字典是一种可变的数据类型。字典是无序的。
字典和列表一样，都是用来存储数据的，只是存储的方式不一样。字典是python里唯一具有映射关系的数据类型。字典的查询效率要高于列表，列表的存储方式是线形存储，复杂度是ON,而字典它的复杂度只有1，字典的存储空间要大，因为它要建立一张映射表，硬射表是要占空间的。我们创建一个字典，就有一个键就对应一个值，它要为这些键值创建一个对应表，而这张表在内存里面是要消耗空间的，所以字典相当于空间换取时间，它用内存的占用量去换取查询的速度。
映射的意思就是一 一对应，一对多。
python的字典就像是现实中的字典一样，每一行目录对应一种字的解释。
1、创建字典的两种方法
（1） ｛｝创建字典
（2） 用内置函数dict( )
变量名=｛“键”，“值”｝
写一个键就能通过哈希算法专进行查询到这个键所对应 的值。
注意事项
1）在字典里键值必须要用引号，否则它会认为是一个变量，最终因为没有给这个变量赋值而报错，用数字没有问题。
2）键具有唯一性。在字典里不能定义两个或两个以上相同的键，否则打印里它只会映射最后一个值。
3）键为不可变数据类型。可以用字符串，整型，元组，用其它数据类型会直接报错。
4）键对应的值可以是任何数据类型。
2、字典的查操作。
查询固定的某一个键下的一个值。通过键去查询：
1) 变量名[ ] 进行查
2） 变量名 . get（）方法进行查 # 推荐使用
用第二种方法取键的值如果取不到可以在后面加上None，给返回一个空值。
字典for循环时，找键的时候是找i ，找值的时候通过d [ i ]去拿
第二种方法是使用%s（格式化输出）来取键和值，
3、字典的增操作
update：更新覆盖，如果有则覆盖，如果没有则添加。
注意：可变数据类型都没有返回值。
4、字典的修改
d [ 要修改的键值 ] = 修改后的值。
如果键已经存在，那么会覆盖原来的键的值。
5、字典的删除
（1）a.pop(键的名称)：a为字典的变量名
（2）del 也能删除字典
（3）clear（）清空整个字典内容
a.clear清空后，字典还在，变成了空字典。
（4）popitem（） 随机删除
补充：
a：所有对象都能调用方法。
b：None并非空值，它不是数据，它可以进行if判断，它本身就是一个结果。None的作用是以后我们写代码报错经常看到的这个NoneType的结果时，我们就应该对应考虑一下是否哪个值为空，导致某些对象不能调用了而报错。
真正为空值的是：空列表｛｝、空元组（）、空字典｛｝、0，这些都是一个个的数据，只是它们里面没有具体的值。
Python漫漫艰辛路之day1