python基础4

day04数据类型

今日类型

• 列表

• 元祖

内容回顾和补充

1. 计算机基础

   • 硬件：cpu/内存/硬盘/主板/网卡

   • 操作系统

     • linux:免费开源
     • windows
     • mac

   • 解释器/编译器

     • 补充：编译型语言和解释器语言？

       • 编译型：c,c++,java,Golang, c#

       #(把代码写完后交给编译器后编译成一个完整的另一个文件再交给计算机执行)
       

       • 解释型：python,php,ruby,js

       (写完代码后，交给解释器，解释器从上到下解释一行计算机执行一行  ，边解释 边执行
       

2. 环境的安装

   • python解释器
     • py2
     • py3
   • 开发工具：pycharm/文本编辑器

3. 学习python语法

   1. 解释器路径

      #！usr/bin/env python
      
      print("你好“)
      

      linux应用：

      • 赋予文件可执行权限rwx等
      • ./hello.py

   2. 编码

      #！usr/bin/env python
      # -*- coding:utf-8 -*-
      print("你好“)
      

   3. 输入输出：

      Py2:

      py3:

   4. 数据类型

      • str独有功能补充：

        1. upper(),lower()

        2. strip()/rstrip()/lstrip()

        3. split(",",1)

        4. replace("old","new",2)

        5. startswith/endswith

           #判断字符串是否已"al"开头
           #方案一 二
           

        6. format()

           #字符串格式化
           name="我叫{0}，年龄:{1}".format("老男孩"，73)
           print(name)
           #”我叫老男孩，年龄：73“
           
           
           

        7. encode():读到内存后的编码格式，默认是按照unicode编码

           #读到内存后的编码格式，默认是按照unicode编码
           name="Gao"
           v1=name.encode('utf-8')#内存中按照utf-8编码方式
           print(v1)
           

        8. ”连字符“.join(users): join会循环users里面的内容然后连接———>join可以循环 (列表，元祖，字符串)

           #1.
           name="alex"
           result="_".join(name)#循环每个字符，并且在字符和字符之间加入连接字符
           print(result)
           #a_l_e_x
           
           #2.连接列表的内容
           users=["Gao","Kou","123"]
           val=",".join(users)
           print(val)
           #Gao,Kou,123
           
           

      • 公共功能

        • len()

        • 索引 index：获取一个字符

        • 切片：获取一段字符串(子序列)

        • 切片步长

          name="alex"
          #value[index0:index2:step]
          #step > 0 :往右边开始取值
          #step < 0  :往左边开始取值
          
          #1.val=name[0:-1:2]#从0到倒数第一个值，每取一次index+2,即就是隔一个取一个
          print(name)
          #ae
          
          #2.val=name[1::2]#从1 到 正无穷 按照step=2向右边取值
          
          #3.val=name[-1:0:-2]#从倒数第一个到0位置处，按照step=-2向左取值
          
          #笔试题：将字符串反转
          val=name[::-1]
          print(val)
          
          

        • for 循环:

        • for in:循环打印字符串的每个字符

        name="Gao"
        for item in name:
        	print(item)
        #G
        #a
        #o
        

        • break/continue依然有效

          name="Gao"
          for item in name:
          	print(item)
          	break
          	print("123")
          #G
          #a
          #o
          

        • for i in range(1,11):

          #请打印1-10
          for i in range(1,11):# 1<=range<11
            print(i)
          #打印1-10 除了7以外
          

        注意：

        ​ for和while应用场景：for:有穷时候优先

        ​ while:无穷

   5. 注释

   6. 条件语句

   7. 循环

   8. 运算符

   9. 字符串格式化

   10. 其他

       • markdown笔记

       • git

         • 本地：git软件[常用命令]

           • git status
           • git add .
           • git commit -m "备注信息"
           • git push -u origin mastor

         • 远程：码云/github

         • 面试相关

           1. 常用git命令

           2. 你们公司是怎么用git作开发的？

              1. 在gitHub上创建仓库

              2. 写自己项目

              3. 将代码提交到远程仓库

                 • 初始化

                   1. 进入一个文件夹 cd /……..

                   2. Git init

                   3. git config --global user.name "用户名”

                   4. git config --global user.email " 邮箱“

                   5. git remote add origin "仓库地址

                      .

                      .

                      .

内容详细

1. 列表

   #表示多个事物
   

   users=["lili","Joe","Mari",99]
   

   • 公共功能

     • len

     • users=["lili","Joe","Mari",99]
       val=len(users)
       print(val)
       #4
       

     • index

       users=["lili","Joe","Mari",99]
       val=users[0]
       print(val)
       #lili
       
       

     • 切片：v[:]

       users=["lili","Joe","Mari",99]
       val=users[0:2]
       print(val)
       #lili
       #Joe
       

     • 步长

       users=["lili","Joe","Mari",99]
       val=users[0::2]
       print(val)
       #lili
       #Mari
       

       #练习
       #输入两个数相加：5+9，5+ 9；5 + 9
       content = input("请输入几个数相加：如5+9:")
       content1 = content.split("+")
       con_len = len(content1)
       sum=0
       index=0
       while index < con_len:
           val = content1[index]
           num = int(val)
           sum = sum+num
           index += 1
       print(sum)
       
       

     • for循环

       • For "ele" in [""]:

       • For "ele" in range(index0,index1,步长):默认顺序输出

         range(0,10): 默认输出0-9

       #1.输出序号和内容
       users=["lili","Joe","Mari",99]
       count=0
       for i in users:
           print(count,i)
           count+=1
       #0 lili
       #1 Joe
       #2 Mari
       #3 99
       
       
       #2.range()默认顺序输出
       users=["lili","Joe","Mari",99]
       val=len(users)
       for index in range(0,val):
         print(index,users[index]) 
         
       #3.反转输出9-0
         print(list(range(9,-1,-1)))
         
       #4.打印0-100之间的偶数
       #方案一
       for count in range(0,101):
           if count%2 == 0:
               print(count)
       #方案二
       for count in range(0,102,2)
       
       #5.给用户展示商品列表 goods=["火车","飞机","大炮"]
       #1 火车
       #2 飞机
       #3 大炮
       #用户输入序号，输出对应的商品
       goods=["火车","飞机","大炮"]
       len1=len(goods)
       for index in range(0,len1):
           print(index+1,goods[index])
       val=input("请输入商品序号：")
       val=int(val)-1
       templ="你选择的商品是：%s"%(goods[val])
       print(templ)
       
       1 火车
       2 飞机
       3 大炮
       请输入商品序号：1
       你选择的商品是：火车
         
       

     • 删除 —> del

     • del users[1:4]#删除1-4
       

       注意：

       • 字符串本身不能删除[不可变类型]
       • 列表是可变类型

       #字符串本身不能修改或者删除
       v1="Gao"
       del v1[1]
       print(v1)
       #报错❌
       

       #列表
       users=["lili","Joe","Mari",99]
       #方案一
       user.pop(1)
       #方案二
       del users[1]
       
       

     • 修改

       #字符串本身不能修改或者删除
       v1="Gao"
       v1[1]=”B“
       print(v1)
       #报错❌
       

       #列表
       users=["lili","Joe","Mari",99]
       #方案一
       user[1]=”Bang“
       #正确
       user[1][0]="R"
       #报错❌
       

   • 独有功能

     1. 追加：Users.append(name)

        users=[]
        for ele in range(0,3):
          name=input("输入内容：")
          users.append(name)
         print(users)
        
        #用户名密码校验
        username=input("name:")
        pwd=input("pwd")
        for ele in users:
          resulr=ele.split(",")
          user=result[0]
          passwd=result[1]
          if user=="username" and passwd=="pwd":
            print("登陆成功")
        

     2. 插入：users.insert(index,"内容")

        users=["lili","Joe","Mari",99]
        users.insert("0","GaoGao")
        print(users)
        #在指定的索引位置进行插入元素
        

     3. 删除（弹出）：

        • users.remove("内容")：从左往右第一单个删除

        • Users.pop(index): 在列表中删除，并可以将值赋值给变量 如不加index代表删除末尾最后一个

          val=users.pop(index)

          users.pop()#如不加index代表删除末尾最后一个
          

        • users.clear(): 清空

     4. users.entend(): 内部实现for循环 通过列表+列表

        #1.把s中的每一个字符添加到users列表中
        s="hfhksk"
        users.extend(s)
        [...,"h","f","h","k","s","k"]
        

        #2.元祖举例
        people=("1","2","bang")
        users.extend(users)#在user中添加
        people.extend(people)#报错   元祖没有extend方法
        

     • 列表嵌套

       users=["Gao",0,True,[11,22,33,"GAO"]]
       user[0]
       users[2]
       users[0][2]#o
       user[3][-1]#GAO
       users[3][-1][-1]#O
       users[3]=666
       

   5.练习

   1.题目将列表中元素使用_连接

   #1.题目将列表中元素使用_连接  
   
      注意点：属于字符串的join()方法，join会循环遍历列表中的每一个元素
      nums=[11,22,33,44]
      val="_".join(nums)
      print(val)
      #报错  因为列表的元素是int类型  没有join()，得先转换成字符串
      #不能直接使用for in 语句
      
      #nums=["11","2","33","44"]
      for i in range(0,len(nums)):
          nums[i]=str(nums[i])
      print(nums)
      
   
      
   

   列表总结：

   • 增

     • append()/insert(index,"")

   • 删

     • remove("内容")/ val.pop(index) / clear()
     • del val[index] ：公共

   • 改

     val[3]="新值"

   • 查

     val[3] / 切片

   • 列表嵌套

2. 元祖

   1. 元祖书写规范

      users=[11,22,33,"老男孩"]#列表(可变)
      users=(11,22,33,"老纳海")#元祖(不可变)
      

   2. 公共功能(int/bool除外)

      1. 索引
      2. 切片
      3. 步长
      4. 删除: (tuple/str除外)
      5. 修改: (tuple/str除外)
      6. for循环
      7. len

   3. 独有功能（没有）

   4. 特殊：元祖中的元素不可被删除/修改

      v1=(11,22,33)
      v1[1]=999#错误
      v1=999#正确
      
      #可以嵌套
      v1=(11,22,(33,44))
      
      v2=[11,22,33,(1,2,3)]
      v2[1]=3838
      v2[-1][1]=5#报错
      
      
      #v1=(11,[1,2,3],22)
      v1[1]=666#错误
      v1[1][2]=123#正确
      

   元组练习(类型判断)

   2.判断v1,v2,v3类型

   v1=1#int
   v2=(1)#int
   v3=(1,)#元组 tuple
   v4=()#tuple
   v5=(1,2,3)#tuple
   print(type(v1),type(v2))
   
   data=[(1),(2),(3)]#[1,2,3]-->list
   
   #元祖只有一个元素时候，末尾一定要加逗号 “ ，”
   

总结

1.解释型语言和编译型语言区别

1.字符串类(不可改变类)

1.独有：

• upper()/lower

• strip() / rstrip() / lstrip()

• replace()

• split()

• isdigit()

• startwith() / endwith()

• format()

• join()

  ​

2.公共

• len()
• index
• 切片
• 切片步长
• for 循环
  • for in
  • break
  • continue
  • for in range(0,10)

3.字符串特性：

• 字符串不可改变——>所以不能删除、修改

2.git命令

3.列表类(可变类型)

• 独有

  • append()

  • insert()

  • pop():只会删掉索引 删掉的值可以付给新变量

  • remove()：直接把值删掉，若找不到值，就会报错

  • clear()

  • extend()

• 公共

  • len()

  • index

  • 切片

  • 步长

  • for循环

  • 修改

  • del val[0:4]

4.元祖(不可变类型)

• 独有：无

• 公共

  • len()
  • index
  • 切片
  • 步长
  • for

• 元祖嵌套