001_python基础

day1-day5

1. python语法

    1> python注释：单行注释   #，pep8规范，快捷键 ctrl + /   ;  多行注释： 三引号，单引号和双引号都可以，3个引号开头，3个引号结尾；

    2> 变量名的命名规范：

         a> 由数字，字母，下划线组成；  

         b> 不能以数字开头；

         c> 不能是关键字，即python已经定义好的，有自己特殊功能的；

         d> 区分大小写；

         f> 见名知意；

 PS：pycharm格式化缩进代码快捷键  Ctrl + Alt + l

 2. 查看python关键字：

import keyword
print(keyword.kwlist)

3. 数据类型：字符串(str)、数字(整数(int)、浮点数(float)、复数(complex))、布尔值(boolean): True、False

     3.1 算术运算符： +  - *  / %

# int float

num1 = 60
num2 = 150

# 加法
print(num1 + num2)
# 减法
print(num1 - num2)
# 乘法
print(num1 * num2)
# 除法
print(num1 / num2)

# 取余(剩余 ) - 找出1-100 能够被2整除
print(num1 % num2)

   3.2 赋值运算符  =  +=  -=

salary = 10000
# salary = salary + 10000
# salary = 20000
salary += 10000 

salary = salary + 10000
print(salary)

   3.3 比较运算符  ==  > <  <=  >= ，结果为布尔值

salary1 = 10000
salary2 = 8000

print(salary1 == salary2)  # 比数值 - 等于
print(salary1 != salary2)  # 比数值 - 不等于

print(salary1 > salary2)  # 比数值
print(salary1 < salary2)  # 比数值
print(salary1 >= salary2)  # 比数值
print(salary1 <= salary2)  # 比数值

print(100 * 2 == 200)
print("hello" == "world")

    3.4 逻辑埏运算符   and(与，都真才为真)   or(或，都假才为假)   not(非，反向)，左边和右边的条件是True或Flase，结果为布尔值

# input: 运行代码的时候,接收用户的输入.
# 变量接收到的用户输入值,均为字符串.
salary = input("请输入你的目标薪资: ")
print(salary)

addition = input("请输入是否双休:双休,单休,大小周")

# # type(变量) - 获取变量的数据类型.
# print(type(salary))

# == 同数据类型的比较.最好是转换为同一个数据类型,再去比较
# 将数字内容的字符串,转成int/float类型. -- int(salary)

# res = int(salary) == 18000
# print(res)
res = (int(salary) == 18000) or not (addition == "双休")
print(res)

# print(not int(salary) > 18000)

4. 字符串：双引号开头，结尾 或是 单引号开头，结尾 或是 三引号开头、结尾

  重点：不管怎么对字符串进行操作，都不会修改原字符串，是重新生成新字符串！！

     4.1  取字符串中某个字符，通过索引/下标获得，有正向索引和反向索引；

str_empty = ''  # 空字符串
print(str_empty)

str_py37 = "hello,py37,study python string data type!"

# 字符串变量名[下标] - 从0开始
print(str_py37[4])
print(str_py37[100])  # IndexError  下标越界。string index out of range

# # 字符串长度是多少呢？  功能 - len(字符串变量名)
length = len(str_py37)
print(length)

# 取最后一个值。长度为41，下标从0-40
print(str_py37[40])
print(str_py37[length - 1])
print(str_py37[-1])

      4.2  取字符串中某些字符，通过切片获得；

           1> 切片:字符串变量名[起始下标:终点下标:步长] 起始下标默认为0，步长默认为1；

           2> 切片时，左闭右开，取头不取尾；

           3> 取得的字符： 起始下标+步长  索引所指的字符；

           4> 步长为正，代表正序取值；步长为负，代表倒序取值；

str_py37 = "hello,py37!"
# 取hello，下标为 0，1，2，3，4
print(str_py37[0:5:1] 
print(str_py37[0:5])  # 0,1,2,3,4
print(str_py37[:5])  # 0,1,2,3,4

#字符串倒序输出
print(str_py37[::-1])
print(str_py37[-2:-8:-2])

      4.3 字符串操作

          1> 大小写转换： lower()    upper()

          2> 查找：find(sub)  如果找到了sub，返回的是sub字符串起始下标，如果没找着，返回的是-1；

                        find(sub,start,end) 从start下标开始找，找到end下标结束，返回的也是sub字符串起始位置

str_py37 = "hello37,PY37,you are welcome,python37,good!"
# 小写、大写
new_str = str_py37.lower()  # 全部都转成小写
print(new_str)

new_str = str_py37.upper()  # 全部都转成大写
print(new_str)

res = str_py37.find("370")
print(res)

res = str_py37.find("37")
print(res)

res = str_py37.find("37",7,12)
print(res)

        3> 替换：replace(old,new)   匹配到的所有都会替换，替换的内容只能是字符串，否则报错 TypeError ；

                     replace(old,new,count)  只替换到指定次数的内容；

str_2 = "hello,py37,hello,body!"
new_str1 = str_2.replace("hello", "666")
print(new_str1)

new_str2 = str_2.replace("hello", "666",1)
print(new_str2)

# 替换的值，只能是字符串
# 否则会报错： TypeError: replace() argument 2 must be str, not int
# new_str3 = str_2.replace("hello", 666,1)
# print(new_str3)

new_str = str_2.replace("nmb666", "哎呀，妈呀",1)
print(new_str)

         4> 获取子字符串索引的起始位置：index(sub)，若sub不存，则报错  ValueError: substring not found

my_hobby = "Never stop learnoing!"

print(my_hobby.index("learn")) #若子字符串不存,报错
print(my_hobby.index("w"))
print("-------------------")
print(my_hobby.find("learn"))  # 若没有找到返回-1,不会报错

5. 格式化输出：字符串中有部分的内容需要动去变化时，需要用到格式化输出

       1> format() 函数 ： {}  占位符，替换占位符时可以是任意类型数据，用法  字符串.format(第1个值即索引0，第2个值即索引1，第3个值即索引2)

age = input("请输入你的年龄：")
height = 155
# 一个萝卜一个坑。第一个萝卜填第一个坑，第二个萝卜填第二个坑，以此类推。。
print("小简今年的年龄是：{}，身高是：{}cm".format(age,height))

print("{} * {} = {}".format(8, 8, 8*8))
# # 一个萝卜要填在几个坑里。要重复使用某一个值
print("{0} * {0} = {1}".format(8, 8*8))

     2> {:.2f} 在字符串中显示2位小数点

     3> {:.2%} 在字符串中显示2位小数点的百分比

# 在字符串里显示小数点。 {:.2f} 表示显示小数点2位
print("{} * {} = {:.2f}".format(8.12, 6.22, 8.12 * 6.22))
# 在字符串里面显示百分比。
print("今天来上课的人占比为：{:.0%}".format(0.95903))

    4> f表达方式   (python3.7新增加)

print(f"{8} * {8} = {8*8}")
num1 = 100.111
num2 = 200.25
res = num1 * num2
print(f"{num1} * {num2} = {res:.2f}")
print(f"今天星期五，对吗？？{100 == 100}")

6. 列表 list  []

    6.1 列表基础

         1> 概念： 列表每个成员之间以,隔开，成员可是任意类型，且是可以重复的

         2> 列表是有序的，故可以通过索引/下标取消  列表名[下标]，下标从0开始，下标同样不能越界，否则报错

         3> 由于列表是有序的，故支持切片，即  列表名[开始索引(默认为0):结束索引:步长(默认为1)]

         4> 列表名.index(成员)： 获取某一个成员的下标

# 空列表,空列表取值报错
list_empty = []
list_empty[0] = "小阿卷"
print(list_empty)  # IndexError: list assignment index out of range


list_py37 = ["浪子", "阿然", "小安", "我比天贵", "Mr 马", "记不住名字", "小安"]
py37_teacher = ['小简']
py37_listsss = [111,2.22,['aa','bb']]

#取值
print(list_py37[2])

# 支持切片 列表名[开始索引(默认为0):结束索引:步长(默认为1)]
print(list_py37[:4])
# 列表反转
print(list_py37[::-1])

#获取成员对应的下标
member_index = list_py37.index("记不住名字")
print(member_index)

    6.2 列表操作

         1> 列表名.append()： 给列表末尾添加值

         2> 列表名.insert(下标,新的值)： 在某个位置插入某个值

         3> 列表名.extend(新列表)： 将新列表当中的成员，合并到当前列表当中

         4> 列表名[索引] = 新的值：修改索引对应的值

         5> 删除列表成员的方法：

              a> 列表名.remove(要删除的成员) ：删除列表某个成员

              b> del 列表名[下标]：使用del的方法，通过下标删除成员

              c> 列表名.pop():   删除列表的最后一个成员

              d> 列表名.pop(index)： 删除指定下标对应的成员

# 往列表里面，添加值
# 1、append(新的值) - 往列表末尾添加值
list_py37.append("哥爱吹风机啊")
print(list_py37)

# 2、insert(下标,新的值)   - 在某个位置插入某个值
list_py37.insert(1, "陈独秀")
print(list_py37)

# 3、extend(新列表) - 将新列表当中的成员，合并到当前列表当中。
new_list = ["玖yue", "柠檬", "人生", "leisen", "Bodhi", "饭团"]
list_py37.extend(new_list)
print(list_py37)

# 修改索引对应的  列表[索引] = 新的值
list_py37[1] = "吕大钊"
print(list_py37)

# 删除操作
# 通过值来删除 - remove(要删除的成员)
# 从列表里面，删除浪子成员。成员：浪子
list_py37.remove("浪子")
print(list_py37)
list_py37.remove("小安")  # 查看源码：ctrl + B
print(list_py37)


# 通过下标来删除值
del list_py37[2]
print(list_py37)

# 列表名.pop()  删除列表的最后一个
list_py37.pop()
print(list_py37)

# 列表名.pop(index)  删除指定下标对应的值
list_py37.pop(4)
print(list_py37)

      6> len(列表名)： 使用python内置的 len()方法计算列表的长度；

      7> in/not in ： 成员运算符，可以用于判断某个数据是否为列表的成员，结果为True,False；

      8> 列表名.sort() ： 列表的排序方法，默认升序排列，列表名.sort(reverse=True)，降低排序；

      9> sorted(列表)： python内置排序方法，默认升序排列，sorted(列表名, reverse=True) ，降序排序；

      10> 列表反转的方法：

              a> 切片：列表名[::-1]，切片是生成新列表；

              b> 列表名.reverse()：对原列表进行了反转操作，直接修改原列表；

 PS：列表.XXX() - 如果是列表的修改操作，一般是对原列表进行了修改！

      11>  列表名.count("列表成员")：获取成员出现的次数；

# 列表的长度 - len()
new_list = ["玖yue", "柠檬", "人生", "leisen", "Bodhi", "饭团"]
print(len(new_list))

# 成员运算符 in/not in  结果为True,False
print("珍珍" in new_list)
print("人生" in new_list)
print("珍珍" not in new_list)

#列表.sort()   默认为升序
list2 = [100, 34, 22,66,65,123,45]
print("未排序前的原列表:",list2)
list2.sort()
print("升序排序之后的：", list2)  # 对原列表进行了修改
list2.sort(reverse=True)  # 降序排序
print("降序排序之后的：", list2) # 对原列表进行了修改

# 列表反转
# 1、切片  列表名[::-1] - 生成新列表
new_list_stu = new_list[::-1]
print("原始列表：", new_list)
print("切片生成的新列表：",new_list_stu)

# 2、列表.reverse() - 对原列表进行了反转操作
new_list.reverse()
print("调用reverse方法之后的原列表为：",new_list)

# 总结：列表.XXX() - 如果是修改操作，一般是对原列表进行修改。

# 获取成员出现的次数
num = new_list.count("饭团")
print(num)

7. 字符串的split 和 join

       1> 字符串.split(分隔符)：将字符串按分隔符进行切割，得到多个子字符串组成一个列表，分隔符默认为空字符；

       2> 拼接符.join(列表名)：把列表中每个字符串成员，用拼接符拼接成一个字符串；

 PS：用于拼接的列表当中的每一个成员，必须都是字符串，否则会报类型错误：TypeError

# 字符串.split(分割符)
teacher = "名字:小简;年龄:18;地区:长沙"
print("原字符串:",teacher)
res = teacher.split(";")
print("切换得到的列表:",res)

# 拼接符.join(列表)
# 注意：列表当中的每一个成员，必须都是字符串。否则会报类型错误：TypeError
# list1 = ['名字:小简', '年龄:18', '地区:长沙', True]
# new_res = ";".join(list1)
# print(new_res)

list2 = ['名字:小简', '年龄:18', '地区:长沙']
new_res = " - ".join(list2)
print(new_res)

 7. 字典 dict {}

      7.1 字典基础

          1> 概念：键值对(key-value) ，无序 ，key是要唯一的/不重复的/不可变类型，一般都是字符串，而value可以为任意类型。

          2> empty_dict = {} ，空字典

      7.2 字典操作

          1> 字典[key]： 通过key获取value，如果key不存在于字典当中，就会报错：KeyError；

          2> 字典.get(key)： 获取key对应的value，如果key不存在于字典当中，则为None；

          3>  字典[key] = value：key为字典中存的值时，则是修改字典值，若无该key，则是添加新的key-value；

          4>  字典.setdefault(key,默认的value)：给key设置默认值，如果key存在，不会修改key对应的value，如果key不存在，则会添加该键值对；

# 字典
empty_dict = {}
person_info = {"name": "xj", "age":18, "city": "长沙", "girl": ""}

# 查询 - 通过key去获取
# 1、字典[key] 如果key不存在于字典当中，就会报错：KeyError
print(person_info["age"])
# print(person_info["hobby"]) # 不存在key报错：KeyError

# 2、字典.get(key)  如果key不存在于字典当中，则为None
print(person_info.get("age"))
print(person_info.get("hobby"))


# 添加key-value、修改key对应的value
person_info["name"] = "大简" # 修改
print(person_info)
person_info["hobby"] = ["看书", "睡觉", "看剧"]   # 添加
print(person_info)
person_info["interested"] = {"city": ["深圳","西藏"]}
print(person_info)

# 主要是用新增值上面  setdefault - 设置默认值
# 字典.setdefault(key,默认的value)
# 如果key存在，不会修改。如果key不存在，则会添加键值对
person_info.setdefault("height", 155)
person_info.setdefault("name", "小简简")
print(person_info)

     7.3 字典常用操作

          1> 原字典.update(新字典)： 将新字典合并到原字典中；

          2> del 字典[key]：删除字典某个key-value；

          3> 字典名.pop(key)：删除字典某个key-value；

          4> 字典名.keys()：获取所有的keys；

          5> 字典.values()：获取所有values；

          6> 字典.items()：获取所有key-value；

          7> in/not in： 成员运算；

          8> len(字典名)：获取字典长度；

# 2个字典合并
# 字典1.update(新字典)  将新字典合并到字典1当中
person_info = {'name': '大简', 'age': 18,"sex": 'girl', 'hobby': ['看书', '睡觉', '看剧']}
new_dict = {"sex": "girl", "weight": 90}
person_info.update(new_dict)
print(person_info)

# 删除操作 - 演示1个  del操作，pop操作也可以的
del person_info["sex"]
person_info.pop('age')
print(person_info)

# 要获取所有的keys - 字典.keys()
print('所有keys:',person_info.keys())

# 要获取所有的values - 字典.values()
print('所有values:',person_info.values())

# 要同时获取所有的key-value  - 字典.items()
print('所有key-value:',person_info.items())

# 成员运算符
print("name" in person_info)
print("name" in person_info.keys())
print(18 in person_info.values())
print(('name', 'xj') in person_info.items())

# 获取长度 - len(字典)
print(len(person_info))

 8. 元组 tupe ()

       1> 概念：有序，值可以重复，可以为任意类型，但是建议用不可变类型，因为它是不可变的，只可以读取，不可以对进行修改；

       2> 元组名[索引]：获取元组值，索引从0开始

       2> (值1,)：一个值的元组，后面的逗号不可以没有，否则就不是元组；

data1 = (1,)
print(data1)
print(type(data1))

data2 = (1)
print(data2)
print(type(data2))

# 第一种赋值
data1 = (1, 2, 3)

# 第二种赋值
data2 = 1, 2, 3
print(data2)

9. 列表，字典，元组区别

    1> 列表：有序、有索引、值可以重复/任意类型；

    2> 字典： 无序，key不可以变，不可重复；

    3> 元组： 与列表一样，有序有索引，值可以重复，但是不可变；

 10. 常用的数据类型：

不可变量类型：int，float,str,bool, tuple
可变类型：list, dict

 11. 控制流

      11.1 if   if  或  if...else  或 if ...elif(可以多个) ...else

       用法一：

     if 条件1:
         条件1为真时，执行这个代码
  用法二：
     if 条件1:
         条件1为真时，执行这个代码
     else:
         条件1不为真时，执行这个代码

  用法三：
     if 条件1:
         条件1为真时，执行这个代码
     elif 条件2:
         条件2为真时，执行这个代码
     else:
         条件1和条件2都不为真时，执行这个代码

score = input("请输入你的作业分数: ")
if int(score) == 100:
    print("太优秀了，学的太好了！！")
    print("奖励一朵小红花！！")
    print("太秀了！")

print("**********************")

if int(score) == 100:
    print("太优秀了，学的太好了！！")
    print("666666666666666")
elif 80 <= int(score) < 100:
    print("还不错，可以继续努力！")
elif 60 <= int(score) < 80:
    print("刚刚及格，加油！！")
else:
    print("得再加把劲儿！！")
    
# 输入星期一二三四五,都是要上班的; 星期六，星期天，不上班的
working_day = ["星期一","星期二","星期三","星期四","星期五"]
weekend = ["星期六","星期天"]

value = input("请输入周一到周天：")
if value in working_day:
    print("guaiguai去上班")
elif value in weekend:
    print("happy，休息了！")

      11.2 while 循环 

           1> while 条件:

           条件为真，会执行的代码。
           直到有一个条件不满足:
           退出循环(break)

    2> 死循环：写代码的时候，一定要避免死循环。
       第一种：在while运行的过程当中，改变了条件中用的数据/变量。总有一次让while的条件不成立
       第二种：使用break

    3> while的特点：由条件来决定循环次数，故当我们的应用场景，不确定循环次数的时候，使用while

score = int(input("请输入一个数字: "))
while score >= 80:
    print("优秀优秀！！！")
    score -= 1  # 在while运行的过程当中，改变了条件中用的数据/变量。总有一次让while的条件不成立。
    if score == 85:
        break  # 退出while循环

while score in [87,88,89,90]:
    if score < 90:
        break

     11.3 for循环

          1> for一般是遍历多成员的对象，如列表/字典/元组/字符串；

          2> 语法：

               for 变量名 in 列表/字典/元组/字符串:

          取到每一个成员后，会执行的代码
   3> 列表的遍历：
      a> 直接遍历列表每个成员
      b> 通过遍历列表的下标，取得列表每个成员
   4> range([起始整数],结束整数,[步长]): 生成一个整数列表，起始整数默认为0，步长默认为1  左闭右开(取头不取尾)
      range(5) --> [0,1,2,3,4]
      range(1,5) --> [1,2,3,4]
      range(1,10,2]  --> [1,3,5,7,9]

   5> break: 退出循环
      continue: 跳过本轮循环，不执行continue之后的代码。直接进入下一轮循环

new_list = ["玖yue", "柠檬", "人生", "leisen", "Bodhi", "饭团"]

# 1、遍历列表的值(成员)
for item in new_list:
    if item == "人生":
        continue
    print(f"哈罗，{item}")

print("************")

for item in new_list:
    if item == "人生":
        break
    print(f"哈罗，{item}")

print("************")
# 2、遍历列表的下标，通过下标去取值 [0,1,2,3...]
for i in range(len(new_list)):
    print(i) # 索引
    print(new_list[i]) # 索引对应的值
    print("索引为 {} 的值是: {}".format(i,new_list[i]))

       6> 字典的遍历：

            a> 遍历key：for key in dict.keys() 或 for key in dict

            b> 遍历key-value：for item in dict.items()  或 for key,value in dict.items()

person_info = {"name": "xj", "age":18, "city": "长沙", "girl": ""}
for key in person_info.keys():
    print(key)

print(person_info.items())

for item in person_info.items():
    print(item)

for key,value in person_info.items():
    print(f"{key}: {value}")

     11.4 双重for循环

"""
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

1、找规律：每一行是什么规律？每一列又是什么规律？
行： 行号
每一行的变化,跟行号/行有什么关系？
第1行：1
第2行：1 2
第3行：1 2 3
第4行：1 2 3 4
第5行：1 2 3 4 5
每一行，从1开始，递增1,到行号打止！
"""
# print输出功能 ，有个参数是end，作用就是调用完1次print后，会做的动作。默认是换行
for index in range(1,2): # 2,3,4,5,6
    print(index, end=" ")  # end就是调用完1次print后，会做的动作。默认是换行

for num in range(2,7):
    # print(num)
    for index in range(1, num):  # 2,3,4,5,6
        print(index, end=" ")
    print()

 
12. pycharm提交代码步骤：
     1> stash changes： 将本地的全部改动临时保存到本地仓库，并撤销了本地的所有改动

 

        2> 给保存的代码，存储为0126_1

 

     3> 拉取远程仓库最新的代码： pull ，将本地的代码更新为最新

 

      4> unstash changes： 将刚才保存到本地仓库的改动代码合并到本地最新代码上，如果有冲突，自己手动修改即可

 

 

     5> 提交代码：commit 选择需要提交的代码文件，  commit and push，这样就完成了代码的提交