python基础

第一个Python程序

name = input('please input your name:') #可以让你显示一个字符串来提示用户
print('Hello' , name)#会依次打印每个字符串，遇到逗号“,”会输出一个空格

运行上面的程序，第一行代码会让用户输入任意字符作为自己的名字，然后存入name变量中；第二行代码会根据用户的名字向用户说hello，名字。
注释
单⾏注释: # 被注释的内容
多⾏注释:’’’ 被注释的内容 ‘’’, “”“这个也是多⾏注释”""
格式化输出
%s: 字符串的占位符, 可以放置任何内容(数字)
%d: 数字的占位符
int(str) # 字符串转换成int
str(int) # int转换成字符串

数据类型和变量

整数
Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。
字符串
字符串可以⽤单引号，双引号，或者三引号引起来，没有什么区别，只是⼀些特殊的格式需要不⽤的引号。
输出单引号可以使用双引号引，输出双引号可以用三引号引起来。三引号也可以引一段话。
字符串只有 + *。’ + '代表字符串的拼接，‘ * ’ 代表字符串重复次数。

s1 = 'a '
s2 = 'bc'
print(s1 + s2)
print(s2*8)

布尔值(bool), 真或者假, True和False。
布尔值可以用and、or和not运算。
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
变量
推荐使用驼峰体或下划线命名。
驼峰体: 除⾸字⺟外的其他每个单词⾸字⺟⼤写。
下划线: 每个单词之间⽤下划线分开。
常量
在python中不存在绝对的常量. 约定俗成, 所有字⺟⼤写就是常量
例如: PI = 3.141592653

字符串操作

字符串是不可变的对象, 所以任何操作对原字符串是不会有任何影响的

切片和索引

1. 索引. 索引就是下标. 切记, 下标从0开始
2. 切片, 我们可以使⽤下标来截取部分字符串的内容
   语法: str[start: end]
   规则: 顾头不顾腚, 从start开始截取. 截取到end位置. 但不包括end
   切片语法:str[start : end : step]
   start: 起始位置 end: 结束位置 step:步⻓
   步⻓: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是1

s1 = "HelloWorld"
print(s1[-1]) # -1 表示倒数.
print(s1[1, 10, 2]) # 字符从1到10，没隔两个取一个字符

大小写转换

capitalize() ： 首字母大写
upper() : 全部大写
lower() ： 全部小写
swapcase() ： 大小写反转
title()： 标题首字母大写

替换与切割

replace() 字符串切割函数

s8 = "sylar_alex_taibai_wusir_eggon"
ret = s8.replace('alex', '⾦⻆⼤王') # 把alex替换成⾦⻆⼤王
print(ret) # sylar_⾦⻆⼤王_taibai_wusir_eggon
ret = s8.replace('i', 'SB', 2) # 把i替换成SB, 替换2个
print(ret) # sylar_alex_taSBbaSB_wusir_eggon

split()字符串切割

s9 = "alex,wusir,sylar,taibai,eggon"
lst = s9.split(",") # 字符串切割, 根据,进⾏切割
print(lst)

坑，如果切割符在左右两端. 那么⼀定会出现空字符串.深坑请留意

s11 = "银王哈哈银王呵呵银王吼吼银王"
lst = s11.split("银王") # ['', '哈哈', '呵呵', '吼吼', ''] 

格式化输出

s12 = "我叫%s, 今年%d岁了, 我喜欢%s" % ('sylar', 18, '周杰伦') # 之前的写法
s12 = "我叫{}, 今年{}岁了, 我喜欢{}".format("周杰伦", 28, "周润发") # 按位置格式化
s12 = "我叫{0}, 今年{2}岁了, 我喜欢{1}".format("周杰伦", "周润发", 28) # 指定位置
s12 = "我叫{name}, 今年{age}岁了, 我喜欢{singer}".format(name="周杰伦", singer="周润发", age=28) # 指定关键字

查找

startswith():查找开头
endswith()：查找结尾
count():查找字符出现次数
find():查找字符出现位置
index():查找索引位置

s13 = "我叫sylar, 我喜欢python, java, c等编程语⾔."
ret1 = s13.startswith("sylar") # 判断是否以sylar开头
ret2 = s13.endswith("语⾔.") # 是否以'语⾔.'结尾
ret3 = s13.count("a") # 查找"a"出现的次数
ret4 = s13.find("sylar") # 查找'sylar'出现的位置
ret5 = s13.find("tory") # 查找'tory'的位置, 如果没有返回-1
ret6 = s13.find("a", 8, 22) # 切⽚找
ret7 = s13.index("sylar") # 求索引位置. 注意. 如果找不到索引. 程序会报错

遍历

我们可以使⽤for循环来遍历(获取)字符串中的每⼀个字符
语法: for 变量 in 可迭代对象

s19 = "⼤家好, 我是VUE, ⼩朋友们. 你们好么?"
#⽤while循环
index = 0
while index < len(s19):
	print(s19[index]) # 利⽤索引切⽚来完成字符的查找
	index = index + 1
#for循环, 把s19中的每⼀个字符拿出来赋值给前⾯的c
for c in s19:
	print(c)
'''
 in有两种⽤法:
 1. 在for中. 是把每⼀个元素获取到赋值给前⾯的变量.
 2. 不在for中. 判断xxx是否出现在str中.
'''
print('VUE' in s19)

其他操作

计算字符串长度
len()是python的内置函数. 所以访问⽅式也不⼀样. len()和print()⼀样

len("Hello")

去掉空格和指定字符

ret = s7.strip() # 去掉左右两端的空格
ret = s7.lstrip() # 去掉左边空格
ret = s7.rstrip() # 去掉右边空格
s1 = "abcdefgabc"
print(s1.strip('abc')) #defg

判断字母和数字
isalnum()# 是否由字⺟和数字组成
isalpha()# 是否由字⺟组成
isdigit()# 是否由数字组成
isdecimal()
isnumeric() # 这个⽐较⽜B. 中⽂都识别.

# 条件判断
s14 = "123.16"
# 是否由字⺟和数字组成
print(s14.isalnum())
# 是否由字⺟组成
print(s14.isalpha())
# 是否由数字组成, 不包括⼩数点
print(s14.isdigit())
print(s14.isdecimal())
print(s14.isnumeric()) # 这个⽐较⽜B. 中⽂都识别.

join函数的使用

li = ["李嘉诚", "麻花藤", "⻩海峰", "刘嘉玲"]
s = "_".join(li)#'李嘉诚_麻花藤_⻩海峰_刘嘉玲'
li = "⻩花⼤闺⼥"
s = "_".join(li)#'⻩_花_⼤_闺_⼥'

center(): 居中，默认填充空格
expandtabs()更改tab的⻓度

s6 = "alex wusir\teggon"
print(s6.expandtabs()) # 可以改变\t的⻓度, 默认⻓度更改为8

列表和元组

列表

列表是python的基础数据类型之⼀. 它是以[ ]括起来, 每个元素⽤’ , '隔开⽽且可以存放各种数据类型。⽽且列表是有序的(按照你保存的顺序),有索引, 可以切⽚⽅便取值.
索引和切片
列表支持修改，字符串不能修改
list[1]:索引 list[1:3:1] 切片

lst = ["麻花藤", "王剑林", "⻢芸", "周鸿医", "向华强"]
print(lst[0]) # 获取第⼀个元素
lst[3] = "流动强" # 注意. 列表是可以发⽣改变的. 这⾥和字符串不⼀样
s0 = "向华强"
s0[1] = "美" # TypeError: 'str' object does not support item assignment 不允许改变
#切片
print(lst[1:3:1]) # 倒着带步⻓

列表的增删改查

list.append()#追加
list.insert()#在某个位置插入
list.extend()#迭代添加

lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]
lst.append("wusir")
lst.insert(1, "刘德华") # 在1的位置插⼊刘德华. 原来的元素向后移动⼀位
# 迭代添加
lst.extend(["张⼀⼭", "苦海⽆涯"])

pop()#删除某个位置元素
remove()#删除指定元素
clear()#清空列表
del

lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]
deleted = lst.pop() # 删除最后⼀个
el = lst.pop(2) # 删除2号元素
lst.remove("麻花藤") # 删除指定元素
# lst.remove("哈哈") # 删除不存在的元素会报错
# # print(lst)
lst.clear() # 清空list
# 切⽚删除
del lst[1:3]

列表的改

lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天"]
lst[1] = "太污" # 把1号元素修改成太污
lst[1:4:3] = ["麻花藤", "哇靠"] # 切⽚修改也OK. 如果步⻓不是1, 要注意. 元素的个数
lst[1:4] = ["李嘉诚"] # 如果切⽚没有步⻓或者步⻓是1. 则不⽤关⼼个数

查询, 列表是⼀个可迭代对象, 所以可以进⾏for循环

for el in lst:
	print(el)

列表的其他操作

count()#查询元素出现的次数
sort()#排序，默认升序
reverse()#元素反转
len()#列表长度

lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天", "太⽩"]
c = lst.count("太⽩") # 查询太⽩出现的次数
lst = [1, 11, 22, 2]
lst.sort() # 排序. 默认升序
lst.sort(reverse=True) # 降序
lst = ["太⽩", "太⿊", "五⾊", "银王", "⽇天", "太⽩"]
lst.reverse()
l = len(lst) # 列表的⻓度

列表的嵌套

采⽤降维操作.⼀层⼀层的看就好.

lst = [1, "太⽩", "wusir", ["⻢⻁疼", ["可⼝可乐"], "王剑林"]]
# 找到wusir
print(lst[2])
# 找到太⽩和wusir
print(lst[1:3])
# 找到太⽩的⽩字
print(lst[1][1])
# 将wusir拿到. 然后⾸字⺟⼤写. 再扔回去
s = lst[2]
s = s.capitalize()
lst[2] = s
print(lst)
# 简写
lst[2] = lst[2].capitalize()
print(lst)
# 把太⽩换成太⿊
lst[1] = lst[1].replace("⽩", "⿊")
print(lst)
# 把⻢⻁疼换成⻢化疼
lst[3][0] = lst[3][0].replace("⻁", "化")
print(lst[3][0])
lst[3][1].append("雪碧")
print(lst)

元组和元组嵌套

元组: 俗称不可变的列表.⼜被成为只读列表。⽤⼩括号括起来, ⾥⾯可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 但就是不能改。
关于不可变,: 这⾥元组的不可变的意思是⼦元素不可变. ⽽⼦元素内部的⼦元素是可以变, 这取决于⼦元素是否是可变对象.

tu = (1, "太⽩", "李⽩", "太⿊", "怎么⿊")
print(tu[0])
print(tu[2:5]) # 切⽚之后还是元组
# for循环遍历元组
for el in tu:
	print(el)
# 尝试修改元组
# tu[1] = "⻢⻁疼" # 报错 'tuple' object does not support item assignment
tu = (1, "哈哈", [], "呵呵")
tu[2].append("麻花藤") # 可以改了. 没报错

元组中如果只有⼀个元素. ⼀定要添加⼀个逗号, 否则就不是元组。元组也有count(), index(), len()等⽅法.

tu = (1,)
print(type(tu))

字典

字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯⼀的. 在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中.这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key’必须是可hash的,如果你搞不懂什么是可哈希, 暂时可以这样记, 可以改变的都是不可哈希的, 那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址⽽规定的.

已知的可哈希(不可变)的数据类型: int, str, tuple, bool
不可哈希(可变)的数据类型: list, dict, set

语法 :{key1: value1, key2: value2…}
注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据

# 合法
dic = {123: 456, True: 999, "id": 1, "name": 'sylar', "age": 18, "stu": ['帅 哥', '美⼥'], (1, 2, 3): '麻花藤'}
print(dic[123])
print(dic[True])
print(dic['id'])
print(dic['stu'])
print(dic[(1, 2, 3)])
# 不合法
# dic = {[1, 2, 3]: '周杰伦'} # list是可变的. 不能作为key
# dic = {{1: 2}: "哈哈哈"} # dict是可变的. 不能作为key
dic = {{1, 2, 3}: '呵呵呵'} # set是可变的, 不能作为key

dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽hash表不是连续的. 所以不能进⾏切片⼯作. 它只能通过key来获取dict中的数据。

字典的增删改查

增加

dic = {}
dic['name'] = '周润发' # 如果dict中没有出现这个key, 就会新增⼀个key-value的组合进dict
dic['age'] = 18
# 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值
dic.setdefault('李嘉诚') # 也可以往⾥⾯设置值.
dic.setdefault("李嘉诚", "房地产") # 如果dict中已经存在了. 那么setdefault将不会起作⽤

删除

ret = dic.pop("jay")
del dic["jay"]
ret = dic.popitem()# 随机删除.
dic.clear()# 清空字典中的所有内容

修改

dic = {"id": 123, "name": 'sylar', "age": 18}
dic1 = {"id": 456, "name": "麻花藤", "ok": "wtf"}
dic.update(dic1) # 把dic1中的内容更新到dic中. 如果key重名. 则修改替换. 如果不存在key, 则新增.

查询

print(dic['name'])
# print(dic['sylar']) # 报错
print(dic.get("ok"))
print(dic.get("sylar")) # None
#如果key不存在，可以返回None，或者自己指定的value
print(dic.get("sylar", "1")) # 1

其他相关操作

字典的键值遍历

dic = {"id": 123, "name": 'sylar', "age": 18, "ok": "科⽐"}
print(dic.keys()) # dict_keys(['id', 'name', 'age', 'ok']) 不⽤管它是什么.当 成list来⽤就⾏
for key in dic.keys():
	print(key)
print(dic.values()) # dict_values([123, 'sylar', 18, '科⽐']) ⼀样. 也当
list来⽤
for value in dic.values():
	print(value)
print(dic.items()) # dict_items([('id', 123), ('name', 'sylar'), ('age',18), ('ok', '科⽐')]) 这个东⻄也是list. 只不过list中装的是tuple
for key, value in dic.items(): # ?? 这个是解构
	print(key, value)

字典的嵌套

# 字典的嵌套
dic1 = {
 "name": "汪峰",
 "age": 18,
 "wife": {
 "name": '章⼦怡',
 "age": 28
 },
 "children": ['第⼀个⽑孩⼦', '第⼆个⽑孩⼦'],
 "desc": '峰哥不会告我吧. 没关系. 我想上头条的' }
print(dic1.get("wife").get("name"))

set 集合

set中的元素是不重复的.⽆序的.⾥⾯的元素必须是可hash的(int,str,tuple,bool)。 set就是dict类型的数据但是不保存value, 只保存key。 set也⽤{}表示
使⽤这个特性.我们可以使⽤set来去掉重复
给list去重复

lst = [45, 5, "哈哈", 45, '哈哈', 50]
lst = list(set(lst)) # 把list转换成set, 然后再转换回list
print(lst)

set集合增删改查

增加：add()增加，update()迭代增加

s = {"刘嘉玲", '关之琳', "王祖贤"}
s.add("郑裕玲")
s.update("麻花藤") # 迭代更新
print(s)#{'麻', '王祖贤', '关之琳', '郑裕玲', '藤', '花', '刘嘉玲'}
s.update(["张曼⽟", "李若彤","李若彤"])
print(s)#{'麻', '王祖贤', '关之琳', '李若彤', '郑裕玲', '张曼⽟', '藤', '花', '刘嘉玲'}

删除：pop()随机删除一个，remove()删除指定元素，clear()清空

s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
item = s.pop() # 随机弹出⼀个.
s.remove("关之琳") # 直接删除元素
# s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错
s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和dict区分的.

修改：不能直接修改，可以先删除再添加

# set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改. 
# 我们可以采⽤先删除后添加的⽅式来完成修改操作
s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
# 把刘嘉玲改成赵本⼭
s.remove("刘嘉玲")
s.add("赵本⼭")

查找：迭代的方式进行查找

# set是⼀个可迭代对象. 所以可以进⾏for循环
for el in s:
	print(el)

常用操作

交并差集

s1 = {"刘能", "赵四", "⽪⻓⼭"}
s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
# 交集
# 两个集合中的共有元素
print(s1 & s2) # {'⽪⻓⼭'}
print(s1.intersection(s2)) # {'⽪⻓⼭'}
# 并集
print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
# 差集
print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
print(s1.difference(s2)) # {'赵四', '刘能'}
# 反交集
print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "⽪⻓⼭"}
# ⼦集
print(s1 < s2) # set1是set2的⼦集吗? True
print(s1.issubset(s2))
# 超集
print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))

分支结构

if语句

第⼀种语法:
 if 条件: #引号是将条件与结果分开。
 	结果1。 # 四个空格，或者⼀个tab键，这个是告诉程序满⾜这个条件的
 结果2。
#如果条件是真(True) 执⾏结果1, 然后结果2, 如果条件假(False) 直接结果2
第⼆种语法:
 If 条件:
 	结果1
 else:
 	结果2
 代码3
第三种语法:
 If 条件1:
 	结果1
 elif 条件2:
 	结果2
 ..
 else:
 结果n

while循环

while True:
	 print('我们不⼀样')

for循环

range可以帮我们获取到⼀组数据. 通过for循环能够获取到这些数据.

for num in range(1, 10, 2):
	print(num)

break和continue

1, break: 立刻跳出循环. 打断的意思
2, continue: 停⽌本次循环, 继续执⾏下⼀次循环

字符编码

Unicode标准最常用的是UCS-16编码，用两个字节表示一个字符（如果要用到非常偏僻的字符，就需要4个字节）。
Unicode可以编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。
用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode转换为UTF-8保存到文件：
浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

for num in range(1, 10, 2):
	print(num)

is 和==的区别

is 比较的是地址
== 比较的是值