python基础入门1
字符编码
字符编码说明：为了解决乱码问题
字符------------>编码------------->数字
字符<------------编码<-------------数字
编码解码要参考字符编码表，字符编码表上存放着字符与数字的对应关系；存取用的字符编码表必须要保持一致
字符编码详细解释：
ASCII码：用8个二进制数对应一个英文字符，只能识别英文字符
gbk码:用16个二进制数对应一个字符，该字符可以是中文字符/英文字符
utf-8:
万国字符---------->内存：unicode格式的数字------------------>硬盘：utf-8格式的数字
中文\英文字符------------>内存：unicode格式的数字------------>硬盘：gbk格式的数字
unicode:1.用16个二进制数对应一个字符 1.兼容万国字符 2.兼容各种老的字符编码
目前形式：
1.内存固定是unicode格式的二进制，我们可以改变是存取硬盘的编码形式
2.存取用的字符编码表必须要保持一致
3.python3解释器已经解决了乱码问题
注意：读取和存储的硬盘编码必须一致
x="上" #unicode二进制字符
字符------>编码----->unicod------->编码--------->其他编码格式
res=x.encod("utf-8)
字符------>编码----->unicod------->编码--------->其他编码格式
res=x.decod("utf-8")
变量
1.什么是变量:
变：事物的状态是发生改变的 量:事物的状态
变量:把我们的事物状态记录下来，以后会改变；变量是一种存取内存的机制
2.为何要有变量
为了让计算机像人一样己住事物状态
3.如何用变量
原则：先定义，后引用
定义变量：三大组成部分（变更名，赋值符号，变量值（事物的状态，存的数据））
1.1变量名：用来访问值
命名规则-见名知意:
1.只能是字母，数字或下划线任意组合
2.第一个字符不能是数字
3.关键字不能用【and，as,assert,break,class等】
命名风格：
1.驼峰体 AgeName = 18 （类名）
2.纯小写加下划线 age_name = 18 (变量名)
3.越精简越好
1.2赋值符号：把变更值得内存地址绑定给变量
1.3变量值：就是我们记录的事物状态，存数据
特征：
1.类型:变量值类型 函数：type()
2.身份ID:内存地址 函数：id()
变量值类型：因为事物状态不同，所以对应着就应用用不同类型
1.整型 18
2.浮点型 1.8
3.字符型 女
GC垃圾回收机制：主要使用引用计数（reference counting）来跟踪和回收垃圾
1.引用变量：
x=100 #引用计数为1
y=x #引用计数为2
x=200 #引用计数为1
2. 循环引用带来的内存泄漏；在引用计数的基础上，使用“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题；
3. 分代回收（使用“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率；分代回收是建立在标记清除技术基础之上）
小整数池优化机制：常驻内存（整数：-5~256；字母；）
4.常量:不变化的量
写法：命名纯大写 AGE = 18
1.基本数据类型
python常用的类型和内置方法：(强类型语言需要类型转换)
可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典;
不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间）;
1.布尔值：True|False
#所有数据类型都自带布尔值;布尔类型的值通常都是比较运算得到的
None，0，空（空字符串，空列表，空字典等）三种情况下布尔值为False
其余均为真
2.int:18:整型:不可变类型：记录人的年龄|等级|号码等；
定义方式： age = 10
类型转换： int(age) #用int工厂函数来定义整型类型，将纯字符型10转为整型
常用操作+内置方法：算法运算+比较运算
3.float:3.8:浮点型:不可变类型：记录任得薪资|身高|体重等；
定义方式： level = 3.8
类型转换： float(level) #用float工厂函数来定义浮点型类型，将字符型3.8转为浮点型
常用操作+内置方法：算法运算+比较运算
4.str:"age":字符型:不可变类型: 记录描述性值得状态等(利用'',"",""" """来定义字符,可利用符号不同进行嵌套)；
定义方式： name = "age"
类型转换： str(age) #用str工厂函数来字符串类型，将任意类型转为字符型
常用操作：
4.1: r:将特殊字符进行转译
name1 = "\test\test" >>> est est
name2 = r"\test\test" >>>\test\test
4.2:按索引取值：1.只能取值2.可正向取值3.可反向取值
name = "hello"
print(name[0]) >>>h
print(name[-1]) >>>o
4.3:切片(头，尾，步长):1.顾头不顾尾 2.复制操作，不是剪切操作
name = "hello"
print(name[0:-1:1]) >>>hell
print(name[:]) >>>hello
print(name[0:4:2]) >>>hl
print(name[::-1]) >>>olleh
4.4:len():计算字符的个数函数
print(len("hello")) >>>5
4.5:in和not in:判断一个字符串是否在大字符串中
4.6:for 循环
内置方法：
4.1 str1.strip():默认移除空白
name1 = "hello"
name2 = name1.strip('h') >>>ello
name3 = name1.rstrip('o') >>>hell
name4 = name1.lstrip('h') >>>ello
4.2 str1.split():切分成列表类型
name1 = "helhlo"
name2 = name1.split('h') >>>['', 'el', 'lo']
name3 = name1.rsplit('o') >>>['helhl', '']
4.3 "".join(list):把一个纯字符串的列表拼接成字符串
name1 = ['', 'el', 'lo']
name2 = ";".join(name1) >>>;el;lo
print(type(name2)) >>><class 'str'>
4.5 str1.lowser()|str.upper():大小写转换
print("HELLO".lower()) >>>hello
print("hello".upper()) >>>HELLO
不同方式转换大小
str1.capitalize():把首字母大写
str1.swapcase():翻转 string 中的大小写
str1.title():所有单词都是以大写开始，其余字母均为小写(判断用istitle())
4.6 str1.startswith()|str2.endwith():判断开头结尾字符
print("hello".startswith("h")) >>>True
print("hello".endswith("o")) >>>True
4.7 str1.replace():替换字符
print("hello".replace("l", "w")) >>>hewwo
4.8 str1.format():格式化字符串
print("hello {y} {x}".format(x=18, y="lili"))
>>> hello lili 18
4.9 str1.find()与str.index()返回索引值
区别：index方法不存在的时候报错；find()不存在返回-1
msg = "hello world"
print(msg.find("hello")) >>>0
print(msg.index("hello")) >>>0
4.10str1.count():返回字符出现次数
msg = "hello world"
print(msg.count("hello")) >>>1
4.11字符格式对齐
str1.center()|ljust()|rjust:返回字符居中|左对齐|右对齐，用空格填充宽度
msg = "hello world"
print(msg.center(20, "*")) >>>****hello world*****
print(msg.ljust(20, "*")) >>>hello world*********
print(msg.rjust(20, "*")) >>>*********hello world
str1.zfill():右对齐，用0补充长度
msg = "hello world"
print(msg.zfill(20, "*")) >>>000000000hello world
4.12判断字符串（结果为布尔值）
str1.isdigit():只能纯数字结果才为真,判断是否为数字
print("113".isdigit()) >>>True
str1.isalnum():至少有一个字符并且所有字符都是字母或数字
str1.isalpha():至少有一个字符并且所有字符都是字母
str1.isdecimal():只包含十进制数字
str1.isnumeric():只包含数字字符
str1.isspace():只包含空格
5.tuple:(1,2,3):元组:不可变类型：按照位置(索引)存多种数据类型(元组是一种不可变的列表);
定义方式： tuple1 = (1,2,3) #注意当元组只用一个元素要加, 如:(1,)
类型转换： tuple():将列表类型转为元组类型
常用操作：
tuple1 = (1, 2, 3, 3, 5)
5.1：按照索引取值1.可读值不可改值2.可正向取值3.可反向取值
5.2：切片(同list相同)
5.3：长度(同list相同)
5.4：成员运算in和not in(同list相同)
5.5: 循环(同list相同)
内置方法：因为元组不可变类型，就有两种方法
5.1：元素在元组中出现的次数
print(tuple1.count(3)) >>>2
5.2:检索首次出现的元素，并返回其位置
print(tuple1.index(5)) >>>4
6.list:[1,2,3]:列表：可变类型:按照位置(索引)存多种数据类型；
定义方式： list1 = ["12",3,3,[666,777]]
类型转换： list():将元组转换为列表
常用操作：
6.1:按照索引取值1.可读可改2.可正向取值3.可反向取值
list1 = [1, 3, "test"]
print(list1[2]) >>>test
list[2]="test2"
print(list1) >>>[1,3,"test2"]
6.2:切片
list1 = [1, 3, "test"]
print(list1[0:5:2]) >>>[1, 'test']
print(list1[::-1]) >>>['test', 3, 1]
print(list1[::1]) >>>[1, 3, 'test'] #同copy一样（浅拷贝）
6.3:"".join(list):把一个纯字符串的列表拼接成字符串
name1 = ['', 'el', 'lo']
name2 = ";".join(name1) >>>;el;lo
print(type(name2)) >>><class 'str'>
6.4:长度
print(len(list1)) >>>3
6.5:成员运算in 和 not in
for i in list1:
print(i)
6.6：循环
for i in list1:
print(i)
内置方法：
6.1:追加
list1.append(67)
print(list1) >>>[1, 3, 'test', 67]
6.2:插入
list1.insert(1,"xxxx")
print(list1) >>>[1, xxx, 3, 'test']
6.3:统计某个元素个数
list1 = [1, 3, "test"]
print(list1.count(1)) >>>1
6.4:获取对象在列表中首次出现的位置
list1 = [1, 3, "test"]
print(list1.index(3)) >>>1
6.5:列表倒过来 #另一种表达方式为list3=list2[::-1]
list1 = [1, 3, "test"]
list1.reverse()
print(list1) >>>['test', 3, 1]
6.6:拷贝(浅拷贝)
test2 = list2.copy()
print(test2) >>>[1, 3, "test"]
6.7:把字符中的每个元素都加入列表
list1 = [1, 3, "test"]
print(list1.extend("hello")) >>>[1, 3, "test", "h", "e", "l", "l", "o"]
6.8:列表排序(元素中都为同种类型)
list2 = [1, 3, 2]
list2.sort()
print(list2) >>> [1, 2, 3]
6.9:清空列表
list2.clear()
print(list2) >>>[]
6.10:三种删除方式
#三种方式
#1.执行索引删除：
res2 = list1.pop(-1) #从尾删除
res3 = list1.pop(0) #从头删除
print(res2) #返回值为删除的值
#2.指定元素删除：
res1 = list1.remove("test")
print(res1) #返回none 单纯删除没有返回值
#3.万能删除
del list1[0] #返回none 单纯删除没有返回值
del list1 #返回none 单纯删除没有返回值
7.dict:{"age"=1, "lihua"=2}:字典:可变类型:按照key:vlaue存多种上数据类型;
说明：key必须为不可变类型，通常为字符串类型，字典是无序的
定义方式： dic1 = {"age"=1, "lihua"=2}
类型转换：
print(dict()) >>>{} # 创建空字典
print(dict(a='a', b='b', t='t'))
>>>{'a': 'a', 'b': 'b', 't': 't'}
print(dict(zip(['one', 'two', 'three'], [1, 2, 3]))) # 映射函数方式来构造字典
>>> {'three': 3, 'two': 2, 'one': 1}
print(dict([('one', 1), ('two', 2), ('three', 3)])) # 可迭代对象方式来构造字典
>>> {'three': 3, 'two': 2, 'one': 1}
常用操作:对于字典来说，可以根据不存在值得可以，但是对于不存在值，列表会报错
例如：dict1={"name":"lili"}
1.按照key取值
print(dict["name"]) >>lili
2.添加
dic1[key] ="value" #对于字典类型来说，key不存在，但可以添加
dic1.append()
3.成员运算in和not in(判断的是key)
4.删除方法
1.万能删除
del dict1["name"]
print(dict1) >>{}
2.clear清空删除
dic1.clear() #清空字典
print(dic1) >>>1
3.字典独有的删除方法
print(dict1.pop("name")) >>>lili #返回删除key得value值，此删除为有序删除
dic1.popitem() >>>("name","lili") #返回删除值放在元组，此删除随机删除
内置方法： dic1 = {"age"=1, "name"="lihua"}
1.dic1.get() #根据key取值,有利于判断取值
pirnt(dic1.get("age")) >>>1
print(dic1["age"]) >>>1
#get()和[]的取值方法区别：当key不存在时,[]报错，而get()返回值为None
2.dic1.len() #长度
print(len(dict1)) >>>2
3.字典独有遍历方式(默认遍历方法为key)
dic1.keys #取键key,
dic1.values #值value
dic1.items #键值对items()
#python2同python3返回值区别：python2返回值放在列表中耗费内存，而python3改良返回函数，有利于内存优化
4.dic1.updata() #更新字典;当key存在就更改值;当key不存在时添加key:value
dic1.update({"name" = "huali"})
print(dic1) >>>{"age"=1, "name"="huali"}
5.dic1.copy() #浅拷贝
6.{}.fromkeys() #快速遍历列表将值成字典
dic1 = {}.fromkeys(["name" , "age"],[11,12])
print(dic1) >>>{'name': [11, 12], 'age': [11, 12]}
dic1["name"].append(111) #formkeys后的字典，当append时候，所有值都会改变
print(dic1) >>>{'name': [11, 12, 111], 'age': [11, 12, 111]}
9.dic.setdefault() #如果字典中存在key，则不动value，如果不存则写入默认值；
dic1 = {"name":"lihua"}
dic2 = {"name":"lihua", "age":12}
dic1.setdefault("age", 18)
dic1.setdefault("age", 18)
print(dic1) >>> {"name":"lihua", "age":18}
print(dic2) >>>{'name': 'lihua', 'age': 12}
集合类型
set:{111，222，333，（1，2，3）}:集合：可变类型：在{}内用,逗号分割开多个元素；
类型函数：set()
元素的值特点：1.必须是不可变类型 2.集合内元素无序 3.集合内元素不能重复
set1 = {111，222，333，（1，2，3）}
print(set1) >>>{33, (1, 2, 0), 222, 111}
常用操作：
1.去重功能
print(set{"hello"}) >>> {'o', 'h', 'e', 'l'}
2.len() #长度
3.成员运算 in 和not in
内置方法
1.set1.add() #添加元素
set1 = {1,2,3,(1,2,3)}
set1.add("test")
print(set1) >>>{1, 2, 3, 'test', (1, 2, 3)}
2.s1.update() #更新元素
set1 = {1,2,3,(1,2,3)}
set1.update({1,10})
print(set1) >>>{1, 2, 3, 10, (1, 2, 3)}
3.删除元素
3.1set1.pop() #随机删除，有返回值
set1 = {1,2,3,(1,2,3)}
print(set1.pop()) >>>1
print(set1) >>>{2, 3, (1, 2, 3)}
3.2set1.remove(value) #当值不在时，报错,无返回值
set1 = {1,2,3,(1,2,3)}
set1.remove(1)
print(set1) >>>{2, 3, (1, 2, 3)}
3.3set1.discard() #当值不在时，不报错
set1 = {1,2,3,(1,2,3)}
set1.discard(1)
print(set1) >>>{2, 3, (1, 2, 3)}
3.3set1.clear() #清空
set1 = {1,2,3,(1,2,3)}
set1.clear()
print(set1) >>>set()
2.基本运算符号
在等号左边为赋值行为,不在左边都是取值行为
1.算术运算符:用于数字类型用
+:加法（也可以用于其他类型）
-:减法
*:乘法（也可以用于其他类型）
/:除法
//:整除(取整数)
%:取余数
**:取平方
2.比较运算符：
==:等于（所有类型，不报错）
!=:不等于（所有类型，不报错）
>=:大于等于（主要用于数字类型，字符按照编码表比大小，列表按照对应位置比大小）
<=:小于等于（主要用于数字类型，字符按照编码表比大小，列表按照对应位置比大小）
3.赋值运算符
=：赋值
+=：增量赋值 (age +=1 等同于 age = age + 1 ） 系列：-=,*=,/=等
: 链式赋值 (x=y=z=10 说明：连续将10给x,y,z)
: 交叉赋值 (x,y=y,x 说明：将x值给y,y值给x)
: 解压赋值
1.size = [1,2,3,4] x1,x2.x3,x4=size 说明将size[0]给x1 size[1]给x2 size[2]给x3 size[4]给x4 必须赋值与取值个数相同
2.size = [1,2,3,4] x1,*x,x3=size 说明将size[0]给x1 size[2]给x2 size[1]给x
3.size = [1,2,3,4] x1,*_=size 说明将size[0]给x1 size[2]给x2 size[1]给x
4.逻辑运算符(只要结果为布尔值，都可以作为条件)
短路运算：尽可能让优先级提前，优先级：()>not>and>or
not:条件取反结果为true：not 条件1
and:同时满足两个条件即为true：条件1 and 条件2
or:满足其中一个条件即为true: 条件1 or 条件2
5.身份运算符（如果id相同，值一定相同；值相同，id不一定相同）
is：判断的是id是否相同
==: 判断的是值是否相同
注意：当判断是否为None时候用is
集合关系运算
关系运算:一个集合体和另一个集合体的运算关系
linux = {"liu", 'bai', "lin"}
python = {"guo", "bai", "yu"}
1.| 并集
print(linux | python) >>>{'guo', 'lin', 'bai', 'liu', 'yu'}
print(python.union(linux)) >>>{'lin', 'bai', 'liu', 'guo', 'yu'}
2.& 交集
print(linux & python) >>>{'bai'}
print(python.intersection(linux)) >>>{'bai'}
#s1.isdisjoint判断是否没有交集
s1 = {1,2,3}
s2 = {1,2,4}
s3 = {4,5,6}
print(s1.isdisjoint(s2)) >>>False
print(s1.isdisjoint(s3)) >>>True
3.- 差集
print(linux - python) >>>{'liu', 'lin'}
print(python - linux) >>>{'guo', 'yu'}
print(python.difference(linux)) >>>{'guo', 'yu'}
python.difference_update(linux)
print(linux) >>>{'liu', 'lin', 'bai'}
4.^ 对称差集
print (python ^ linux) >>>{'guo', 'lin', 'yu', 'liu'}
5.== 相等互为父子集
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) >>>True
5.1>,>= 父集
s1={1,2,3}
s2={1,2}
print(s1 >= s2) >>>True
print(s1.issuperset(s2))>>>True
5.2<,<= 子集
print(s2 <= s1) >>>True
print(s2.issubset(s1)) >>>True
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
