基础篇

计算机简介:

      计算机基本组成:主板+CPU+内存

       CPU:主频、核数.  主频和核数越大CPU越好.

       内存:大小(8G,16G,32G)、型号(DDR3,DDR4,DDR5)、主频(海盗船,玩家国度)

       显卡:显存,型号(N,A. 其中N型号中倒数第二个数越大越好例如:N-GTX 1080 TI),位宽

       硬盘:西数,希捷,日立,东芝

     计算机最低层是:电子电路,只能识别0,1.

python简介:

    python是解释性、弱类型语言.

    python的优点:

     (1)定位"优雅","明确","简单"; (2)开发效率高;(3)python是一门高级语言; (4)可移植性;(5)可扩展性;(6)可嵌入性;

    python的缺点:

      (1)速度慢;(2)代码不能加密;(3)线程不能利用CPU问题.

    python解释器:cpython,ipython,pypy(运行速度快),jython,ironpython

 

变量命名规则:

    (1)由数字,英文,下划线组成;

    (2)不能由数字开头.更不能是纯数字;

    (3)不能是关键字;

    (4)不能是中文;

    (5)不能太长;

    (6)要有意义;

    (7)区分大小写;

    (8)推荐使用驼峰和下划线两种类型

常量:全部字母大写就是常量,约定俗成.

 

python数据类型:

     (1)int(整数)  用于计算和大小比较    +,-,*,/,%(取余数),//(整除),<,>,<=,>=,!=(不等于)

     (2)str(字符串)  用',","""引起来都是字符串.     +(连接),*(重复)

     (3)bool(布尔值)   只有两个结果true和false

if判断:

     最基本用法
  if 条件判断:
   代码块
  运行流程. 当条件是真. 执行代码块
  
  if 条件:
   代码块1
  else:
   代码块2
  执行流程: 当条件成立. 执行代码块1. 否则, 执行代码块2. 二选一
  
  if 条件1:
   代码块1
  elif 条件2:
   代码块2
  .....
  else:
   代码块n
  执行流程:　满足条件1执行代码块1;满足条件2执行代码块2;满足条件n执行代码块n.

# 单行注释    '''多行注释 

\n 换行    在print语句之后,python解释器会自动添加换行符      ==表示判断

用户输入input接收的内容永远是字符串

例1:print("周杰伦说:\"昆凌也不错.\"")   print('周杰伦说:"昆凌也不错."')    输出周杰伦说:''昆凌也不错.''

例2:print("你好,",end="")  print("欢迎光临")     输出你好,欢迎光临

例3:if语句的两种写法

(1)
num=int(input("请输入一个数"))
if num>66:
 print("猜测结果大了")
elif num<66:
 print("猜测结果小了")
else:
 print("猜测结果正确")
(2)
num=int(input("请输入一个数"))
if num>66:
 print("猜测结果大了")
else:
 if num<66:
  print("猜测结果小了")
 else:
  print("猜测结果正确")

 

 while循环:

while 条件:

    代码块  #循环体

    运行流程:如果条件为真，那么循环体则执行

             如果条件为假，那么循环体不执行

例 

count=1
while count<=5:
    print("你很帅!")
    count=count+1

如果在循环的过程中，因为某些原因，你不想继续循环了，怎么把它中止掉呢？这就用到break 或 continue 语句

break用于完全结束一个循环，跳出循环体执行循环后面的语句continue和break有点类似，区别在于continue只是终止本次循环，接着还执行后面的循环，break则完全终止循环

例

while True:
    s=input("请输入你的聊天内容:")
    if s=='q':
        break
    print("请开始你的表演:"+s)

例

while True:
    s=input("请输入聊天内容:")
    if s=="q":
        break
    if "马化腾"in s:
        print("你输入的内容不合法!")
        continue
    print("请开始你的表演:"+s)

例  1+2+3+4+...+100=?

count=1
sum=0
while count<=100:
    sum=sum+count
    count=count+1
print(sum)

例  1--100之间的奇数

count=1
while count<=100:
    if count%2!=0:
        print(count)
    count=count+1

while 后面的else 作用是指，当while 循环正常执行完，中间没有被break 中止的话，就会执行else后面的语句

 

格式化输出:

%s就是代表字符串占位符，%d,是数字占位符,%f,小数占位符

例

name = input("请输入你的名字:")
age = input("请输入你的年龄:")
hobby = input("请输入你的爱好:")
gender = input("请输入你的性别:")
print("%s今年%s岁,爱好%s,性别%s" % (name,age,hobby,gender))

如果字符串中有占位符,那么后面所有的%都是占位,需要转译,如果没有占位符%可以直接用.

例

s = "网球"
print("%s受到全世界%%30人们的喜欢." % s)

 

运算符:

算数运算符:+,-,*,/,**,%,//

比较运算符:==,!=,<>(不等于),<,>,<=,>=

赋值运算:=,+=(例 a+=1相当于a=a+1),-=,*=,/=,**=,%=,//=

逻辑运算:

and (并且)左右两端都是真,运算结果为真

or(或者)左右两端有一端为真时.运算结果为真

not(非)原来是假,现在是真.

在没有()的情况下not 优先级高于 and，and优先级高于or，即优先级关系为( )>not>and>or，同一优先级从左往右计算

例

not 2>1 and 3<4 or 4>5 and 2>1 and 9>8 or 7<6  #false
    F   and   T   or  F  and  T  and  T or F
          F       or         F          or F
    F

编码:

1.ASCII  8位(bit) 1个字节  最多有256个位置,包含英文字母大小写.数字.标点等特殊符号.

2.国标码 GBK 16位(bit) 2个字节 包含大部分常用的汉字.

3.万国码 Unicode 32位(bit) 4个字节

4.utf-8 :    英文  8位(bit) 1个字节

                欧洲文字  16bit  2个字节

                中文   24bit 3个字节

8bit=1byte    1byte=1kb   1024kb=1mb   1024mb=1GB   1024GB=1TB

1024TB=1PB  1024PB=1EB  1024EB=1ZB  1024ZB=1YB  1024YB=1NB

 

数据类型:

1.int 整数  bit_length()求二进制长度   

2.bool  布尔

3.str  字符串     存储少量数据

4.list  列表    例:["123","abc",]

5.tupe  元组  只读列表,不能改.

6.dict  字典  一对一对的存储数据  key:value   

7.set  集合  存储不重复的内容,保存大量内容.

 

int类型: 

只能进行求二进制长度操作

例   

a=27  ==>  a=11011(二进制)
print(a.bit_length())    ==<5>

bool类型:

取值只有True或False.bool值没有操作

字符串转换:

例:

i=2
s=str(i)                             总结:转换成...就有...把目标括起来
print(type(s))   ==<class'str'>

例:

b=False
c=int(b)
print(c)    ==<0>    True=1  False=0

例:

s=""
if s:
    print("123")
else:
    print("abc")   ==<abc>    空字符表示False,非空字符表示True.

例:

m=None
if m:
    print("a")
else:
    print("b")     ==<b>   空的都是False,非空都是True

 

字符串str:

1.字符串的索引,切片,步长

索引就是下标,切记,下标是从0开始.

例:

s="我爱吃东西."
print(s[4])      ==<西>

print(s[-1])     ==<.>

通过索引获取到的内容. 还是一个字符串
切片可以对字符串进行截取
语法 s[起始位置: 结束位置]
特点:顾头不顾腚

例:

s="我爱吃东西."
s1 = s[2:5]
print(s1)     ==<吃东西>

例:

s="我爱吃东西."
s3 = s[3:]  # 默认到结尾
print(s3)          ==<东西.>

例:

s="我爱吃东西."
s4 = s[:3] # 从头开始
print(s4)         ==<我爱吃>
s5 = s[:]   # 从头到尾都切出来
print(s5)         ==<我爱吃东西.>

例:

s="我爱吃东西."
s6 = s[-2:] # 从-2 切到结尾  默认从左往右切
print(s6)       ==<西.>

步长:
语法:ｓ[起始位置: 结束位置: 步长]

例:

s = "我是梅西,我很慌"
s1 = s[1:5:2]   # 从1开始, 到5结束, 每2个取1个
print(s1)     ==<是西>

例:

s = "我是梅西,我很慌"
s2 = s[::3]
print(s2)     ==<我西很>
s3 = s[6:2:-2]   # - 表示反着来. 每两个取1个
print(s3)     ==<很,>

2.字符串的相关操作

大小写相关操作

(1)capitalize()  ==首字母大小写

例:

s = "alex and wusir and taibai"
s1 = s.capitalize()  # 首字母大写
print(s)    # 原字符串不变    ==<alex and wusir and taibai>
print(s1)      ==<Alex and wusir and taibai>

(2)upper()==全部大写        (3)lower()==全部小写

例:

s = "Alex is not a Good Man. "
print(s.upper())    ==<ALEX IS NOT A GOOD MAN.>
print(s.lower())   ==<alex is not a good man.>

(4)strip()==去掉两端指定字符,中间去不掉.

例:

s = "*******呵a呵呵呵****************"
print(s.strip("*"))     ==<呵a呵呵呵>

例:

username = input("用户名:").strip()    # 去掉空格.
password = input("密码:").strip()     # 去掉空格
if username == 'abc' and password == '123':
    print("登录成功")
else:
    print("登录失败")

(5)replase 替换

例:

s = "alex wusir alex sb taibai"
s1 = s.replace("alex", "晓雪") # 原字符串不变
print(s1)         ==<晓雪 wusir 晓雪 sb taibai>
 # 去掉上述字符串中的所有空格
s2 = s.replace(" ", "")
print(s2)         ==<alexwusiralexsbtaibai>

s3 = s.replace("alex", "sb", 1)
print(s3)      ==<sb wusir alex sb taibai>

(6)split 切割=刀    切割符左右两边都会出现''空字符.

例:

s = "alex_wuse_taibai_bubai"
lst = s.split("_taibai_")    # 刀是_  切完的东西是列表. 列表装的是字符串
print(lst)      ==<['alex_wuse', 'bubai']>

(7)format 格式化

例:

s = "我叫{}, 我今年{}岁了, 我喜欢{}".format("abc", 123, "456")
print(s)     ==<我叫abc, 我今年123岁了, 我喜欢456>
# 可以指定位置
s = "我叫{1}, 我今年{0}岁了, 我喜欢{2}".format("abc", 18, "456")
print(s)     ==<我叫18, 我今年abc岁了, 我喜欢456>
s = "我叫{name}, 我今年{age}岁了, 我喜欢{mingxing}".format(name="abc", mingxing="456", age=123)
print(s)    ==<我叫abc, 我今年123岁了, 我喜欢456>

(8)startswith  判断字符开头是否以...开头

(9)endswith 判断字符是否以...结尾

(10)count  判断...在字符串中出现的次数

(11)find  查找...在字符串中出现的位置,如果没有出现返回-1

(12)index 查找..在字符串中出现的位置,如果不存在则报错.

例:

s = "abc喜欢123,不喜欢abc"

print(s.startswith("abc"))   # 判断字符串是否以xxx开头      ==<Ture>
print(s.endswith("456"))     # 判断字符串是否以xxx结尾     ==<Flase>
print(s.count("456"))   # 计算xxx在字符串中出现的次数       ==<0>
print(s.find("abc", 3))    # 计算xxx字符串在原字符串中出现的位置, 如果没出现返回   ==<12>  
print(s.index("456"))    # index中的内容如果不存在. 直接报错   

(13)isdigit  判断字符串是否由数字组成

(14)isalpht  判断字符串是否由字母组成

(15)isalnum  判断是否由字母和数字组成

(16)isnumerical  判断是否由数字组成也可以判断中文数字

(17)len()  求字符串的长度

例:

s = "你今天喝酒了么"
i = len(s)  #  print() input() len() python的内置函数
print(i)      ==<7>
i = s.__len__() # 也可以求长度 len()函数执行的时候实际执行的就是它
print(i)      ==<7>

(18) join()把字符串变成列表

例:

s='abc'
s1=s.join("非常可乐")
print(s1)     ==<非abc常abc可abc乐>

例:

s='_'.join(['非','常','可','乐'])
print(s)    ==<非_常_可_乐>

join可以把列表变成字符串

split可以把字符串变成列表

3.字符串的遍历

(1)使用while进行遍历

例:

s = "晓雪老师.你好漂亮"
print(len(s))   # 长度是:８　索引到7    ==<9>
count = 0
while count < len(s):
    print(s[count])
    count = count + 1

(2)使用for进行遍历   

优势:简单
劣势:没有索引

例:

s = "晓雪老师.你好漂亮"
for c in s: # 把s中的每一个字符交给前面的c 循环
    print(c)

语法:

for 变量 in 可迭代对象:

         循环体

 

list列表:

列表可以装大量的数据,不限制数据类型.      表达方式:[],方括号中的每项用","隔开.     列表和字符串一样,有索引和切片

1.列表的增删改查

(1).append("添加的元素")向列表中添加一个元素,默认元素添加到列表的末尾.

例:

lst = ["周杰伦", "王力宏", "周润发"]
lst.append("伍佰")

print(lst)    ==<['周杰伦', '王力宏', '周润发', '伍佰']>

insert(指定位置,"添加的元素")把元素添加的指定的位置,原来在指定位置的元素往后移.

例:

lst = ["周杰伦", "王力宏", "周润发"]
lst.insert(1, "马化腾")    # 把元素插入到指定位置. 元素的移动
print(lst)     ==<['周杰伦', '马化腾', '王力宏', '周润发']>

exend(添加的元素)把元素添加到列表的最后   如果添加的元素是字符串最后列表添加的元素是字符串的每一个元.

迭代添加: 如果添加的是列表最后列表最后添加的是要添加的列表的元素.

例:

lst = ["周杰伦", "王力宏", "周润发"]
lst.extend(["马云"])
print(lst)    ==<['周杰伦', '王力宏', '周润发', '马云']>

例:

lst = ["周杰伦", "王力宏", "周润发"]
lst.extend(["马云", "王健林", "李嘉诚"])    # 迭代添加
print(lst)     ==<['周杰伦', '王力宏', '周润发', '马云', '马云', '王健林', '李嘉诚']>

例: 多次输入名字,按q键停止输入.

lst = []
while 1:
    name = input("请输入学生的名字")
    if name.upper() == "Q":
        break
    else:
        lst.append(name)    # 把名字添加到列表

print(lst)
结果:
请输入学生的名字adf
请输入学生的名字vht
请输入学生的名字tj
请输入学生的名字hm,
请输入学生的名字q
['adf', 'vht', 'tj', 'hm,']         

2.   pop()删除最后一个元素,     pop(删除元素的索引)删除指定索引位置的元素

例:

lst = ["白菜", "大白梨", "茄子", "大白梨"]
e = lst.pop()   # 返回删除的元素, 删除最后一个
print(e)   ==<大白梨>   #删除的元素

print(lst)   ==<['白菜', '大白梨', '茄子']>   #删除最后一个元素的列表

例:

lst = ["白菜", "大白梨", "茄子", "大白梨"]
e = lst.pop(1)  # 根据给出的索引进行删除
print(e)    ==<大白梨>
print(lst)   ==<['白菜', '茄子', '大白梨']>

remove(删除的元素)删除指定元素

例:

lst = ["白菜", "大白梨", "茄子", "大白梨"]
lst.remove("大白梨")
lst.remove("大白梨")
print(lst)    ==<['白菜', '茄子']>

del 列表[]   切片删除

例:

lst = ["白菜", "大白梨", "茄子", "大白梨"]
del lst[1:]    #从索引为1到最后的元素全部删除
print(lst)     ==<['白菜']>

list在循环的时候不能删除,因为会改变索引.

例:

lst=["周杰伦","周润发","周星星","马化腾","周树人"]
for el in lst:
    lst.remove(el)
print(lst)       ==<['周润发', '马化腾']>

例:

lst=["周杰伦","周润发","周星星","马化腾","周树人"]
del_lst=[]
for el in lst:
    if el[0]=="周":
        del_lst.append(el)
for el in del_lst:   #循环记录的内容
    lst.remove(el)   #删除原列表的内容
print(lst)     ==<['马化腾']>

 3. 列表的改

列表的修改利用索引切片的修改

索引修改

例:

lst = ["太白", "五色", "银王", "日天"]
lst[0] = "太黑"
print(lst)       ==<['太黑', '五色', '银王', '日天']>

 迭代修改

例:

lst = ["太白", "五色", "银王", "日天"]
lst[1:3] = "马化腾"    # 迭代修改
print(lst)        ==<['太白', '马', '化', '腾', '日天']>

 例:

lst = ["太白", "五色", "银王", "日天"]
lst[1:3] = ["周杰伦",  "王力宏"]
print(lst)     ==<['太白', '周杰伦', '王力宏', '日天']>

 4.列表的查询

for循环

例:

lst = ["舒克贝塔", "黑猫警长", "熊大熊二", "葫芦娃", "吴佩琪"]
for el in lst:  #  element(元素)
    print(el)
结果:
舒克贝塔
黑猫警长
熊大熊二
葫芦娃
吴佩琪

5.列表的相关操作

(1)len(列表)--列表长度

例:

lst = ["1", "2", "3", "4","2", "6"]
print(len(lst))     ==<6>

(2)count(指定字符)--指定字符的长度

例:

lst = ["1", "2", "3", "4","2", "6"]
print(lst.count("2"))   ==<2>

(3)sort()--排序,数字从小到大      从大到小是sort(reverse)

例:

lst = [1, 9, 18, 2 , 34, 88, 7, 9]
lst.sort()  # 升序
print(lst)        ==<[1, 2, 7, 9, 9, 18, 34, 88]>
lst.sort(reverse=True)  # 倒序
print(lst)        ==<[88, 34, 18, 9, 9, 7, 2, 1]>

(4)reverse--让列表从从右到左(倒序)排列 

 例:

lst = [1, 9, 18, 2 , 34, 88, 7, 9]
lst.reverse()
print(lst)     ==<[9, 7, 88, 34, 2, 18, 9, 1]>

6.列表的嵌套

降维操作

例:

lst = [1, "周杰伦", "张杰", ["周星驰", ["可口可乐"], "陈奕迅"]]
print(lst[3][1][0])   ==<可口可乐>

lst[3][1].append("芬达")
print(lst)      ==<[1,"周杰伦","张杰",["周星驰",["可口可乐","芬达"],"陈奕迅"]]>

lst[2] = lst[2].replace("杰", "键")
print(lst)     ==<[1,"周杰伦","张键",["周星驰", ["可口可乐"], "陈奕迅"]]>

 

tuple元组:

不可变列表,只读列表.  有索引和切片

当元组元素少于等于1时,需要加一个逗号.

例:

lit = (1, "花生", "山药")
print(type(lit))         ==<class"tuple">
tu = (1 )    # 需要添加一个逗号
print(type(tu))          ==<class"int">
tu = (1, )    # 需要添加一个逗号
print(type(tu))          ==<class"tuple">

空元组   tu=tuple()     元组只能进行(1)count()--查找元素出现的次数;(2)index()--查找元素是否存在,不存在直接报错.

元组的遍历:

for  el  in  tu:

      print(el)

元组本身不能改变,元组内部第一层元素不能改变  如果元组中包含列表,则列表是可以变的.

例:

tu = (1, "马化腾", ["胡辣汤", "疙瘩汤", "西红柿鸡蛋汤"])
tu[2].append("粘包米") # 元组本身没有变. 变的是儿子中的内容
print(tu)     ==<(1, '马化腾', ['胡辣汤', '疙瘩汤', '西红柿鸡蛋汤', '粘包米'])>

 

range:

例:

for i in range(10): # 从0开始. 到10结束
    print(i)

例:

for i in range(3, 7):   # 从3 开始. 打印到7结束. 不能到7
    print(i)

例:

for i in range(3, 10, 2):  # 从3 到 10 每2个取一个
    print(i)

例:

for i in range(0, -5, -1):  #从0 开始到-5结束. 倒着数
    print(i)

 

字典(dict):

dict{}:括起来的键值对是字典.{key:value}

字典中的key必须是可哈希的(不可变的).value没有限制.

整数.字符串.元组是不可变的,列表是可变的.

  增:

例:  

dic={"A":"a"}
dic["B"]="b"
print(dic)     ==<{'A': 'a', 'B': 'b'}>

 例:  如果key重复了,value会被替换.

dic={"A":"a"}
dic["B"]="b"
dic["B"]="2"   #赋值
print(dic)     ==<{'A': 'a', 'B': '2'}>

setdefault 如果字典中包含这个key则不再继续保存.

例:

dic={"A":"a"}
dic.setdefault("C","c")
print(dic)    ==<"A":"a","C":"c">

dic.setdefault("C",3)
print(dic)    ==<"A":"a","C":"c">

  删除:

(1)pop(key)

例:

dic={"A":"a","B":"b","C":"c"}
dic.pop("A")
print(dic)    ==<{'B': 'b', 'C': 'c'}>

例:

dic={"A":"a","B":"b","C":"c"}
ret=dic.pop("A")
print(ret)    ==<a>

(2)del dic[key]

例:

dic={"A":"a","B":"b","C":"c"}
del dic["B"]
print(dic)    ==<{'A': 'a', 'C': 'c'}>

(3)popitem()  随机删除

例:

dic={"A":"a","B":"b","C":"c"}
ret=dic.popitem()
print(ret)    ==<('C', 'c')>
print(dic)    ==<{'A': 'a', 'B': 'b'}>

(4)clear  清空

例:

dic={"A":"a","B":"b","C":"c"}
dic.clear()
print(dic)     ==<{}>

dict中的元素在迭代循环的过程中不能执行新增和删除操作.

formkeys 需要一个静态字典,执行fromkeys命令后返回一个新字典和上面定义的字典没有关系.

例:

dict={}
a=dict. fromkeys(['A','B','C'],'ab')
print(a)    ==<{'A': 'ab', 'B': 'ab', 'C': 'ab'}>

修改:

(1)可以用key直接修改.

例:

dic1={"A":1,"D":"d","C":3}

dic1["C"]=dic1["C"]-2
print(dic1)     ==<{'A': 1, 'D': 'd', 'C': 1}>

(2)字典1.update(字典2) 把字典2添加的字典1中,如果字典2中key和字典1中的key重复则替换vlaue,如果不重复,则添加.

例:

dic={"A":"a","B":"b","C":"c"}
dic1={"A":1,"D":"d","C":3}

dic.update(dic1)
print(dic)     ==<{'A': 1, 'B': 'b', 'C': 3, 'D': 'd'}>

   查找:

(1)用key直接查找

例:

dic={"及时雨":"宋江","小李广":"花荣","易大师":"剑圣"}

print(dic["易大师"])   ==<剑圣>

(2)get 如果key不存在则返回None,如果不想找回None可以添加一个默认值.  key存在则返回value

例:

dic={"及时雨":"宋江","小李广":"花荣","易大师":"剑圣"}
print(dic.get("李光","默认值"))    ==<默认值>

(3)setdefault  先判断字典中有没有key,如果没有则添加.  再用这个key去字典中查询,返回查到的结果.

例:

dic={"及时雨":"宋江","小李广":"花荣"}
ret=dic.setdefault("诺手","诺克")
print(ret)     ==<诺克>    #查询
print(dic)     ==<{'及时雨': '宋江', '小李广': '花荣', '诺手': '诺克'}>    #添加 

 相关操作:

(1)keys  返回所有的key  结果像集合像列表但不是列表  可以进行迭代循环.

 例:

dic={"及时雨":"宋江","小李广":"花荣"}
print(dic.keys())    ==<dict_keys(['及时雨', '小李广'])>

for s in dic.keys():
    print(s)       
==<及时雨
   小李广>

(2)values 返回所有的value值   结果像集合像列表但不是列表  可以进行迭代循环.

例:

dic={"及时雨":"宋江","小李广":"花荣"}
print(dic.values())     ==<dict_values(['宋江', '花荣'])>
for s in dic.values():
    print(s)     
==<宋江
   花荣>

(3)items  返回所有key,value值     结果像列表但不是列表,列表中的元素是元组.

例:

dic={"及时雨":"宋江","小李广":"花荣"}
print(dic.items())      ==<dict_items([('及时雨', '宋江'), ('小李广', '花荣')])>#键值对
for s in dic.items():
    print(s)          
    print(s[0])
    print(s[1])

根据解构的一种算法:

dic={"及时雨":"宋江","小李广":"花荣"}
for k,v in dic.items():
    print(k)    
    print(v)

解构,解包

例:

a,b=1,2
print(a)   ==<1>
print(b)   ==<2>

例:

a=1,2  ==>  a=(1,2)
print(a)   ==<(1,2)>

例:

a,b=(1,2)
print(a)    ==<1>

 字典的嵌套

例:

dic={"name":"汪峰",
     "age":58,
     "wife":{"name":"章子怡",
             "age":37,
             "salar":1800000},
     "children":[{"name":"老大","age":18},
                {"name":"老二","age":7}]}
print(dic["wife"]["salar"])          ==<1800000>
print(dic["children"][1]["age"])     ==<7> #第二个孩子的年龄

 

set集合   特点:去重

 

set中的元素是不重复的,无序的里面的元素必须是可哈希的(int,str,tuple,bool).

 

例:

 

s={'王者荣耀','英雄联盟','王者荣耀',123,True,True}
print(s)     ==<{'英雄联盟', True, '王者荣耀', 123}>

 

(1)增:add()   update()

 

(2)删:pop()随机删除   remove()直接删除  clear()清空

 

(3)改:先删后增

 

(4)查:可迭代  for el in set:

 

set集合本身是可以发生改变的,是不可哈希的.我们可以使用frozenset来保存数据.frozenset是不可变的.也就是一个可哈希的数据类型.

 

例:

 

frozenset([1,3,6,6,9,8])
ss={'a',s}
print(ss)     ==<{'a', frozenset({1, 3, 6, 8, 9})}>

 

is和==的区别:

id()内存地址

例:

s="***是***"
abc=id(s)
print(abc)     ==<2573374364144>

例:

lis=["花生","莲蓬","荷花"]
lis1=["花生","莲蓬","荷花"]
print(id(lis))
print(id(lis1))
==<1965904831112
   1965904831048>#内存地址不一样

例:

s="花生"
s1="花生"
print(id(s))
print(id(s1))
==<1486646978848
   1486646978848>#内存地址一样

字符串会进入小数据池,会对字符串进行缓存,为了节省内存.

字符串(str).整形(int).布尔(bool)都有小数据池.

列表(list).元组(tuple).字典(dict)没有小数据池.

注意:在使用字符串的时候,python会帮我们把字符串进行缓存,在下次使用的时候,可以直接指向这个字符串即可,可以节省内存.

==判断左右两端是否相等

is判断左右两边的id是否相等,比较内存地址

例:

lis=["花生","莲蓬","荷花"]
lis1=["花生","莲蓬","荷花"]
print(lis==lis1)      ==<Ture>
print(lis is lis1)    ==<Flase>

编码和解码:

编码:    encode()   之后的内容是bytes(字节)类型

存储前必须先进行编码

硬盘和网络传输都用UTF-8

例:

s="我饿了"
bs=s.encode("UTF-8")
print(bs)     ==<b'\xe6\x88\x91\xe9\xa5\xbf\xe4\xba\x86'>

英文在UTF-8编码之后还是英文

1个中文在UTF-8编码之后是3个字节

 

解码:   decode()   python本身用的就是unicode编码

用什么编码就用什么解码

例:

bs=b'\xce\xd2\xb6\xf6\xc1\xcb'
print(bs.decode("GBK"))    ==<我饿了>解码之后是字符串

例:   UTF-8转换成GBK

'\xe6\x88\x91\xe9\xa5\xbf\xe4\xba\x86'
s=bs.decode("UTF-8")  先把UTF-8解码成unicode字符串
bss=s.encode("GBK")   在把字符串用GBK进行编码
print(bss)    ==<b'\xce\xd2\xb6\xf6\xc1\xcb'>

 

深浅拷贝:

字典,列表进行赋值操作,实际上是引用内存地址的赋值.内存中只有一个列表,两个变量指向一个列表.

例:

lst=["周杰伦","周润发","周星星",]
lst1=lst               #赋值内存地址一样
lst.append("周树人")
print(lst,lst1)      ==<['周杰伦', '周润发', '周星星', '周树人'] ['周杰伦', '周润发', '周星星', '周树人']>

浅拷贝:  copy  只拷贝第一层

例:

lst=["周杰伦","周润发","周星星",]
lst2=lst.copy() == lst2=lst[:]
lst.append("周树人")
print(lst,lst2)     ==<['周杰伦', '周润发', '周星星', '周树人'] ['周杰伦', '周润发', '周星星']>
print(id(lst),id(lst2))   ==<1991369433864 1991369433800>

深拷贝:   deepcopy 深度拷贝包括内部的所有内容进行拷贝

例:

lst1=['A','B','C',['a','b','c']]
lst2=lst1.copy()
lst1[3].append("d")  
print(lst1,lst2)  lst1[3]和lst2[3]的内存地址相同
 ==<['A', 'B', 'C', ['a', 'b', 'c', 'd']] ['A', 'B', 'C', ['a', 'b', 'c', 'd']]>

例:

import copy
lst1=['A','B','C',['a','b','c']]
lst2=copy.deepcopy(lst1)
lst1[3].append("d")
print(lst1,lst2)   ==<['A', 'B', 'C', ['a', 'b', 'c', 'd']] ['A', 'B', 'C', ['a', 'b', 'c']]>

拷贝比创建对象的过程快.

 

文件操作:

在python中打开文件使用open()函数,获取文件句柄,通过操作句柄来进行各种操作.

打开文件的方式有:r,w,a,r+,w+,a+,rb,wb,ab,r+b,w+b,a+b  默认使用的是r(只读)模式.

常用操作:r,w,a,r+

1.只读操作  r

例:

f=open("明星",mode='r',encoding='UTF-8')
s=f.read()
f.close()
print(s)==<周杰伦.郭采洁.容祖儿.邓论>

encoding表示编码集.根据文件的实际保存编码进行获取数据.

绝对路径:(1)从磁盘的根目录开始一直到文件名;(2)互联网上的绝对路径.

相对路径:同一个文件下的文件,相对于当前这个程序所在的文件夹而言.如果在同一个文件夹中.则相对路径就是这个文件名.如果在上一层文件夹.则要../("../"表示返回上层目录)

read(n)读取n个字符.需要注意的是.如果再次读取.那么会在当前位置继续去读而不是从头读.

2.只写操作  w

写的时候,如果没有文件,则会创建文件;如果文件存在,则将文件中的原内容删除,再写入新内容.

例:

f=open("明星",mode='w',encoding='UTF-8')
s=f.write("昆凌")
f.flush()
f.close()    此时文件中的内容只有'昆凌".

在w模式下不能进行读"read"操作.

3.追加  a   写入的内容会追加到文件的末尾

例:

f=open("明星",mode='a',encoding='UTF-8')
f.write("小龙女")
f.flush()
f.close()    此时文件中的内容是"昆凌小龙女"

4.只读字节     rb   读取出来的数据类型是byte类型,不能选择encoding字符集.

例:

f=open("明星",mode='rb')
s=f.read()
print(s)
f.close()     ==<b'\xe6\x98\x86\xe5\x87\x8c\xe5\xb0\x8f\xe9\xbe\x99\xe5\xa5\xb3'>

5.只写字节  wb  可以不指定打开的文件的编码,但在写文件的时候必须将字符串转化成"utf-8"的bytes数据.

例:

f=open("小娃娃",mode='wb')
f.write("你开心吗?".encode("utf-8"))
f.flush()
f.close()      此时小娃娃文件内容"你开心吗?"

6.读写  r+  读写模式默认光标在文件开头.必须先读后写

例:

f=open("小娃娃",mode='r+',encoding="utf-8")
s=f.read()
f.write("邓超")  此时小娃娃内容只有"邓超"
print(s)    ==<你开心吗?>
f.flush()
f.close()

在r+模式中,如果读取了内容,不管读取了多少.后面去写都是追加在末尾.如果没有读取,就在开头覆盖.

7.写读  w+  先将所有内容清空,然后写入,最后读取,但是读取的内容是空的.必需在写完后将光标移动到开头的位置才能读取到内容.

 

相关操作:

1.seek()光标  移动到...位置    单位byte   

例:

f=open("明星",mode='r+',encoding="utf-8")
f.read(3)
f.seek(3)   --光标移动到第一个字的位置

seek(0)在开头  seek(1)在当前  seek(2)在末尾

2.readable()判断文件是否可读

3.writable()判断文件是否可写

4.readlines()拿到列表元素是每行字和\n 可以执行for循环

5.strip去掉空格 换行 制表符

6.truncate()没有参数时从文件截到光标当前位置  truncate(参数)从文件头截到参数的位置.

 

文件内容修改:

with.open打开文件夹不用写close关闭文件夹

例:

import os
with open("菜单",mode="r",encoding="utf-8")as f1,\
        open("菜单_副本",mode="w",encoding="utf-8")as f2:
    s=f1.read()
    ss=s.replace("肉","菜")
    f2.write(ss)
    os.remove("菜单")    #删除原菜单
    os.rename("菜单_副本","菜单")   #将菜单_副本重命名为菜单

例:

f=open("菜单",mode="r",encoding="utf-8")
for line in f:
    print(line)
f.close
梅菜扣肉
                 两个换行一个是文本中的换行,一个是print()中的换行.
红烧肉

酸辣土豆丝

东坡肉

例:

import os
with open("菜单",mode="r",encoding="utf-8")as f1,\
        open("菜单_副本",mode="w",encoding="utf-8")as f2:
    for line in f1:
        ss=line.replace("肉","菜")
        f2.write(ss)
    os.remove("菜单")
    os.rename("菜单_副本","菜单")