python基础是个什么鬼？

 # 定义两个变量

    
 a, b = 1, 2
    
 a > b and a < b      # 判断a > b和a < b为True
    
 a % 2 == 0 or b % 2 == 0      # a % 2 == 0或者b % 2 == 0 ，其中一个成立就判断为True
    
 not a > b    # 判断a不大于b，结果为True

 # 把3赋值给num

    
 num = 3
    
  
    
 # 通过取模运算num是否能被2整除
    
 if num % 2 == 0:
    
     # num是数值不能直接拼接字符串，所以用str()函数转化成字符串再拼接
    
     print(str(num()) + "是一个偶数")  
    
 else:
    
     print(str(num()) + "是一个奇数")

 # 把59赋值给score

    
 score = 59
    
 # 第一个条件是小于60，判断为不及格
    
 if score < 60:
    
    print("成绩不及格")
    
 # 第二个条件是小于90，判断为及格
    
 elif score < 90:
    
    print("成绩及格")
    
 # 第三个条件，大于90，判断成绩优秀
    
 else:
    
 print("成绩优秀")

 # 把100赋值给score

    
 score = 100
    
 # 先判断最>=60，里面嵌套三个条件：大于等于60小于70、大于70小于90、大于90
    
 # 最后判断<=60
    
 if score >= 60:
    
    if score < 70:
    
       print("成绩及格")
    
    elif score < 90:
    
       print("成绩良好")
    
    else:
    
       print("成绩优秀")
    
 else:
    
    print("成绩不及格")

 # 把22赋值给age

    
 age = 22
    
  
    
 # 判断年龄大于18岁并且小于60岁
    
 if 18 < age < 60:
    
    print("成年人了，搬砖！")

 # 执行顺序由上至下

    
 lap = 0
    
  
    
 # 循环条件是lap < 10
    
 while lap < 10:
    
       
    
       # lap的初始值是0，循环条件是每执行一次加上1
    
       lap += 1
    
       
    
       # 循环体，每执行一次打印一次lap+1圈，直到执行完成10次停下来
    
       print("我跑完了第" + str(lap + 1) + "圈")

 # 把字符串apple赋值给seq

    
 seq = "apple"
    
  
    
 # 判断s在seq内（注意：此时的字符串是apple）
    
 for s in seq:
    
     
    
     # 打印s
    
     print(s)    #代码执行后输出一次是 a p p l e

 # 需求：在控制台中打印出指定边长的长方形或者正方形图案。

    
  
    
 # 指定长方形的宽和高
    
 width, hight = 10, 5
    
  
    
 """
    
    print函数有了第二个参数，end表示在打印完指定的内容后，在结尾再打印一个指定的字符
    
 串，默认每个print语句在结尾会加一个换行符"\n", 传递一个空字符串给它，表示打印完星号以后不再
    
 添加任何输出内容。第二个print函数没有任何参数，那它会输出一个换行符。
    
 """
    
  
    
 # 从上到下开始遍历打印高度和宽度
    
 for i in range(height):
    
     for j in range(width):
    
     print("*", end ="")
    
 print()

 # 需求：使用for循环和continue来打印出10以内的所有奇数相加的式子，并求出它们

    
 的和。
    
  
    
 total = 0
    
 for i in range(10):
    
     if i % 2 == 0:
    
    continue
    
     print(i, end = " + ")
    
     total += i
    
 print(" = %s" % total)
    
  
    
  
    
  
    
 # 关键字break用来打断整个循环并跳出。看这个例子，给一个字符串，这个字符串是一个小数，要求打
    
 印出小数的整数部分。
    
 s = "238.9237834829"
    
 for i in s:
    
     if i == '.':
    
    print()
    
    break
    
     print(i, end='')

 # 每三位用逗号分隔

    
 '{: ,}'.format(1234567890)   #结果 1,234,567,890

 s = "CHINA"

    
  
    
 # 结果是C，取第一位
    
 s[0] 
    
  
    
 # 结果是HI,取第一位和第二位，第三位不包含，开区间
    
 s[1:3]
    
  
    
 # 结果是CHINA，0可以不写
    
 s[:5] 
    
  
    
 # 结果是CHINA，若全部不写就是取全部
    
 s[ : ]
    
  
    
 # 结果是INA,从第三位取到尾
    
 s[2:]
    
  
    
 # 结果是 CIA,从头到尾隔两个字符取一个 
    
 s[ : :2]
    
  
    
 # 结果是AIC,从尾开始取，隔两个字符取一个
    
 a[: : -2] 
    
  
    
 # 最后一个字符"A"
    
 s[-1] 
    
  
    
 # 空字符串
    
 s[0:0] 
    
  
    
 # 倒序输出一个字符串, 结果：ANIHC
    
 s[::-1]

 # 去除字符串中头和尾的空格字符

    
 print("   msfnjsfn sd sda ").strip())
    
  
    
 # 想要去除左边的空格
    
 print("  sdsf ".lstrip())
    
  
    
 # 想要去除右边的空格
    
 print("  sdsf  ".rstrip())

 # upper()函数，可以把字符串变成大写

    
 print ('china'.upper())
    
  
    
 # lower()函数，可以把字符串变成小写
    
 print('CHINA'.upper())
    
  
    
 # capitalize()函数，可以把字符串的首字母变成大写
    
 print ('china'.capitalize())
    
  
    
 #title()函数，可以把每个单词的首字母变成大写
    
 print ('china i love you'.title())

 # islower()函数，可以判断字符串是否是小写

    
 print("china".islower())
    
  
    
 # isupper()函数，可以判断字符串是否是大写
    
 print("CHINA".isupper())
    
  
    
 # isdigit()函数，可以判断字符串是否是全是数字，应用场景填写的手机号&金额等
    
 print("123456".isdigit())
    
  
    
 # startswith()函数, 可以判断字符串是否以XX开头，应用场景特殊格式是否符合需求
    
 print("china".startswith('c'))
    
  
    
 # endswith()函数，可以判断是否以指定的字符串结尾
    
 print("china".startswith('a'))

 # find()函数，可以找出子字符串，index()函数也有一样的效果，但是没找到的话会报错，一般不用

    
 password = "123"
    
 input_password = " 56612389"
    
 print (input_password.find(password))
    
  
    
 # count函数，可以找出字符串中某字母一共出现几次
    
 b = "banana"
    
 print(b.count("a"))
    
  
    
 # replace()函数，可以替换字符串中的某一字母或者某一单词
    
 print("aaaddd".replace("a","d")) # --->输出dddddd
    
  
    
 # len()函数，可以显示字符串的长度
    
 print(len("china"))

 # 定义一个元素时，上元组定义的时候也可以不用括号，英文的逗号是必须加的，多个元素可加可不加

    
  
    
 # 输出('solo',)
    
 t = 'solo',
    
  
    
 # 将一个序列强制转换为元组
    
 tuple('abc') # ('a', 'b', 'c')
    
 tuple(range(5)) # (0, 1, 2, 3, 4)
    
  
    
  
    
 # 输出('p', 'y', 't', 'h', 'o', 'n')
    
 t = tuple('python')
    
  
    
 # 输出('p', 'y', 't', 'h', 'o', 'n')
    
 t = ('p', 'y', 't', 'h', 'o', 'n')
    
  
    
 # 输出('p', 'y', 't', 'h', 'o', 'n')
    
 t = 'p', 'y', 't', 'h', 'o', 'n'  
    
  
    
 # 定义元组后通过下标索引访问
    
 t = ('My', 'age', 'is', 18)
    
 t[0] # 'my'
    
 t[-1] # 18
    
  
    
 # 也可以通过切片来访问，注意切片返回的是一个包含切片片段的新元组。
    
 t[0:2] # ('My', 'age')
    
  
    
 # 后面的逗号表明这是一个元组，否则就会被认为是一个字符串。

 # "".join()：字符串中的连接函数“”里面加空格和不加空格打印出来的格式有区别

    
 # 输出结果：'My age is 18'
    
 t = ('My', 'age', 'is', "18")
    
 print(" ".join(t))
    
  
    
 # 元组也支持 in 操作，想要判断元组中是否包含某个元素：
    
 'a' in t # True
    
 'x' in t # False
    
  
    
  
    
 t1 = tuple("python")
    
  
    
 # y在t里面一共出现多少次 ----->输出1
    
 print(t1.count('y')) 
    
  
    
 # n在t里面是什么位置----->输出5
    
 print(t1.index('n')) 
    
  
    
 # 查看T的长度----->输出6
    
 print(len(t1))

 lst = ('a', 'b', 'c', 'd', 'e')

    
 for i in lst:
    
     print(i)

 # 定义了一个空的列表

    
 lst = [] 
    
 lst = list()
    
  
    
 # 定义一个带有4个初始值的列表
    
 lst = [1,2,3,4] 
    
  
    
 # 列表内定义了字符串、整型、浮点型，元组
    
 lst = ["a",1,2,3,3.14,(1,2,3)] 
    
  
    
 # 通过传递可迭代序列：字符串、range()函数、元组转化成列表
    
 lst = list( "asd")
    
 lst = list (range(100))
    
 lst = list ((1,2,3))
    
  
    
 # 列表的访问，可通过索引（根据元素的类型返回）、切片(返回的同类的值)访问
    
 lst = ['a','b','c','d','e']
    
  
    
 # 通过索引访问第一个和最后一个
    
 print(lst[0],lst[-1])
    
  
    
 # 通过切片访问第一个到第三个（不包含），输出结果是['b','c'] 
    
 print(lst[1:3]) 
    
  
    
 # 追加函数append（）
    
  
    
 # 在列表后面最后面添加'f'
    
 lst.append('f') 
    
  
    
 # 查看列表中的长度
    
 print(len(lst)) 
    
  
    
 # 修改列表中的函数，可用list索引
    
 lst[0] = 'A' 
    
  
    
 # del删除函数
    
 del lst[0]  # 删除列表中第一个元素

 lst = ['a', 'c', 'e']

    
  
    
 # 在第二个元素'c'前面插入一个字符串'b'
    
 lst.insert(1, 'b')   # lst现在的值是['a', 'b', 'c', 'e']
    
  
    
 # 在最后一个元素'e'前面插入一个字符串'd'
    
 lst.insert(-1, 'd') # lst现在的值是['a', 'b', 'c', 'd', 'e']

 lst.pop()

    
 last = lst.pop()
    
 print(lst,last) # 输出结果：[lst内的元素] 被删除的元素

 lst = [1, 2, 1, 'a', 'b', 'c']

    
 lst.remove('a')
    
 print(lst) # lst的值为[1, 2, 1, 'b', 'c']
    
 lst.remove(1) # 注意这里的1是元素值，不是索引
    
 print(lst) # lst的值为[2, 1, 'b', 'c']

 lst = [1,2,3,4]

    
 lst.clear()
    
 print(lst) # 结果为[]

 lst = []

    
 lst.extend(range(5))
    
 print(lst) # [0, 1, 2, 3, 4]
    
 lst.extend([5, 6, 7])
    
 print(lst) # [0, 1, 2, 3, 4, 5, 6, 7]

 # lst里面是数字：

    
 lst.sort()  #按照从小到大排序
    
 lst.sort(reverse=True)   #从大到小排序
    
 lst里面是revenue = [('1月',56100000),('2月',46100000),('3月',76100000)]
    
 # 希望按照收入大小来排序，可以引进key参数 = 接收的是一个函数
    
 revenue.sort(reverse= True, key = lamba x: x[1]) #指定让每个元组的第二个索引作为排序依据

 copy函数

    
 lst1 = [1,2,3]  #lst1里面有数组123
    
  
    
 lst2 = lst1 # 把lst1数组的123赋值给lst2
    
  
    
 lst1.append(4) # lst1追加多一个4，lst1=[1,2,3,4]
    
  
    
 print(lst1,lst2)  #lst1和lst都是[1,2,3,4]
    
  
    
 lst3 = lst1.copy() #复制 lst1的值是[1,2,3,4]赋值给lst3
    
  
    
 lst1.append(5) # lst追加5，lst3=[1,2,3,4,5]
    
  
    
 print(lst1,lst3)   #结果：lst1=[1,2,3,4,5],lst3=[1,2,3,4,]

 lst = [i for i in range(20)] #将遍历20内所有的数作为一个元素组成一个列表

    
  
    
 lst = [i for i in range(20) if i % 2 == 0] #在后面加条件，遍历20内所有的偶数
    
  
    
 # 另一种写法：
    
 lst = [i *2 for i in range(10) ] # 在前面加条件
    
  
    
 # 另一种写法：
    
 lst = [i for i in range(0,20,2)] #利用步长取值，从0开始到20之内，每隔2位取一个值
    
 print(lst)

 sales = dict(top_sales)

    
 # sales现在的值变成了
    
 {
    
 'Peter': 213,
    
 'John': 253,
    
 'Tony': 284,
    
 'Henry': 205,
    
 'Mike': 280
    
 }

 # 语法1：

    
 sales = {
    
 'mike'：123，
    
 'emm'：321，
    
 }
    
  
    
 # 语法2：
    
 top_sales = [("mike",123),("emm",321)] # 定义一个变量并赋值列表内的内容给这个变量
    
 print( dict(top_sales))

 # 新增数据：第一步需要设置一个字典里面的值

    
 sales['like'] = 0     # 指定新增一个like=0的数据
    
 print(sales['like'])   # 打印该新增数据的值
    
  
    
 # 修改数据：
    
 sales['like'] = 300 # 指定修改like的值修改成300
    
  
    
 # 删除数据
    
 del sales['like'] # 删除like的值

 for key_value in sales.items():

    
 print(key_value)

    sales.get('不存在的值') # ---->返回none

 # 只想单独列出所有的销售人员名单，可以这样写:

    
 sales.keys()
    
  
    
 # 可以对它进行遍历
    
 for sale in sales.keys():
    
     print(sale)
    
  
    
 # 想计算出所有销售人员的销售额总和，也就是公司总销售额，可以直接取出value部分并求和：
    
 sum(sales.values())

 # 这两种方式都可定义集合

    
 nums = {1, 2, 3, 4, 5}
    
 nums = set([1, 2, 3, 4, 5])
    
  
    
 lst = [1,2,3,4,5,5,1] # 定义一个list的数组
    
 nums = set(lst)  #把lst的传递给一个集合
    
 print(nums) #打印结果是{1，2，3，4，5}
    
  
    
 t= ('a','b','c','a') #定义一个元组
    
 print(set(t))  #用set转化t成一个集合
    
 print(list(nums)) #把nums集合转化成list
    
 print(tuple(nums)) #把nums集合转化成元组

 # 集合的遍历

    
 for n in nums:
    
      print(n)
    
 # 查看集合nums的长度
    
 print(len(nums))  
    
  
    
 # 用in函数来判断5是否存在集合nums中
    
 print(5 in nums) 
    
  
    
 # 用add函数在集合nums中增加一个5，会先判断是否存在，如果存在不会再追加
    
 nums.add(5) 
    
  
    
 # remove函数来删除集合nums中的5，如果删除的是nums中不存在的数5会报错
    
 nums.remove(5)    
    
  
    
 # 用discard函数来删除集合nums中的5，就算5不存在nums中也不会报错
    
 nums.discard(5)  
    
  
    
 # pop函数，删除集合中的某一个值并返回该值,可以一直执行直到集合内为空
    
 num = nums.pop()   
    
  
    
 while len(nums) > 0:   #如果集合nums内的长度大于0
    
     # 一直使用pop函数迭代执行集合nums
    
     num = nums.pop()   
    
     # 打印出集合的值
    
     print(num)

 s1 = {1,2,3，4}

    
 s2 = {3,4,5}
    
 print(s1.intersection(s2)) #求交集，返回{3，4}
    
 s3 = s1.union(s2))  #求并集，返回（1，2，3，4，5）
    
 print(s1.issubset(s3))   #判断是否是子集,返回布尔值True
    
 print(s3.issupperset(s2))   # 判断是否是父集,返回布尔值True

 #定义一个函数是hello2,里面有两个参数（里面还可以继续加参数，用，隔开即可）

    
 def hello2(name,sex):   
    
     if sex == 'boy':      #如果参数sex是boy
    
     print("Hi,Mr.", name)   #打印出Hi,Mr.参数name
    
     elif sex == 'girl':  #如果参数sex是girl
    
     print("Hi, Mrs.",name)   #打印出Hi,Mrs.参数name
    
 hello2('john', 'boy')    #调用hello2,name的值是John，sex的值是boy
    
 hello2('Amy', 'girl')    #调用hello2,name的值是Amy，sex的值是girl
    
 hello2(sex='boy',name='Mike')  #调用hello2,把boy赋值给sex，把Mike赋值给name

 ef multiply(num1, num2)  # 定义一个函数是multiply，里面有两个参数

    
      return num1 * num2  # 返回num1乘以num2的乘积
    
 print(multiply(2, 4))   # 调用multiply函数，num1的值是2，num2的值是4，打印出multiply的返回值是8
    
  
    
  
    
 def permit(age):   # 定义一个函数是permit，里面有一个参数是age
    
       if age >= 18:   # 如果age大于等于18
    
          print("准许进入")   # 打印准许进入
    
          return True     # 返回True，以下代码不执行
    
       else :           # 如果age小于18
    
          print("禁止进入")   # 打印禁止进入
    
          return False     # 返回False，以下代码不执行
    
 permit(18)   # 调用函数permit，age是18
    
 permit(17) # 调用函数permit，age是17
    
 permit(29) # 调用函数permit，age是29

    lambda n: n * n

 revenue = [('1月',5610000),('2月',4850000),('3月',622000)()]

    
 key = lambda x: x[1]     # 定义一个匿名函数key=lambda x，取x得小标是2的值 
    
 for r in revenue:
    
      print(key(r))   #打印key里面的每一项

 class Dog:     #创建一个类是Dog

    
      pass
    
 dog = Dog()
    
 dog1, dog2 = Dog(), Dog()   #根据这个类可以创建N个dog对象
    
 print(dog)

 type(1)

    
 type('abc')
    
 type([])

    print（isinstance(dog, Dog)） #第一个参数是对象dog，第二个参数是需要判断的类

 class Dog:

    
 def __init__(self):
    
     self.breed = None
    
     self.color = None
    
     self.size = None
    
  
    
 def eat(self):
    
     print("I like bones")
    
  
    
 def run(self):
    
     print("I'll catch you.")
    
  
    
 def bark(self):
    
     print('Wang! Wang!')
    
  
    
 dog = Dog()
    
 dog.eat()
    
 dog.run()
    
 dog.bark()
    
 print('一只%s型%s色的%s' % (dog.size, dog.color, dog.breed))
    
  
    
 # 调用不同的方法能打印出不同的内容，体现了不同的行为。但是最后一句话打印出来的内容却是None，因为我们还没有设置相应的属性。

 """

    
 会显示出dog对象的所有属性和方法，包括刚刚定义的那几个方法和属性。对于对象，也可以使用help
    
 函数查看它的帮助文档。
    
 """
    
 dir(dog)
    
  
    
 help(sum)
    
  
    
 help(print)

 # 导入一个math内置模块

    
 import math
    
  
    
 # 可以使用math模块里的所有函数了，可以使用dir来看一下都有哪些函数
    
 dir(math)
    
  
    
 # 也可以使用from ... import ... 这种语句来具体导入某一个子模块或函数
    
 from math import sqrt
    
  
    
 # 这种方式更精确的导入某个函数，使用起来更方便， 但要注意重名的问题。如果说我们的代码本来就有
    
 一个叫sqrt的函数，那我们可以使用 as 关键字来给模块起一个别名
    
 from math import sqrt as squarte
    
  
    
 # 要一次性导入多个模块
    
 import sys, os
    
 from math import sqrt, pow

 from datetime import datetime, timedelta

    
  
    
 # 返回当前时间的detetime对象
    
 now = datetime.now()
    
 type(now)
    
  
    
 # 查看当前时间的年月日
    
 print(now.year, now month, now.day)
    
  
    
 # 查看当前时间戳，精确到时分秒
    
 now.timestamp()
    
  
    
 # 返回指定格式的日期字符串
    
 datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    
  
    
 # 将指定格式的字符串转化成日期时间对象
    
 datetime.strptime('2022-11-29 10:17:30', '%Y-%m-%d %H:%M:%S')

 import time

    
  
    
 # 返回当前时间戳
    
 time.time()
    
  
    
 # 返回房前时间的格式化字符串
    
 time.strftime('%Y-%m-%d %H:%M:%S')
    
  
    
 # 用于脚本调试休眠的time.sleep,休眠3秒
    
 time.sleep(3)

 # 生成一个随机浮点数，范围[0.0, 1.0)

    
 random.random()
    
  
    
 # 生成1到100之间的随机整数，包括1和100
    
 random.randint(1, 100)
    
  
    
 # 从序列中随机抽出一个元素
    
 random.choice(['a', 'b', 'c', 'd', 'e', 'f', 'g'])
    
  
    
 # 从序列中随机抽出k个元素,注意抽出来的元素可能会重复
    
 random.choices(['a', 'b', 'c', 'd', 'e', 'f', 'g'], k=2)
    
  
    
 # 跟choices函数类似，但它是不重复的随机抽样
    
 random.sample(['a', 'b', 'c', 'd', 'e', 'f', 'g'])
    
  
    
 # 将一个序列随机打乱，注意这个序列不能是只读的
    
 lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
    
 random.shuffle(lst)

 # 获取当前的工作目录

    
 print(os.getcwd())
    
  
    
 # 创建目录
    
 os.mkdir(os.getcwd() + '/test')  # 只能创建一层目录
    
 os.makedirs(os.getcwd() + '/test2'/123)  # 创建多层目录
    
 os.listdir(os.getcwd())  # 列出当前工作目录下的内容
    
 os.listdir('/')  #列出根目录下的内容
    
  
    
 os.path.abspath('./')  #获取当前目录的绝对路径
    
 os.path.abspath('..')  #获取父级目录的绝对路径（当前目录的上一级目录）
    
  
    
 # 相对路径：./text.txt ../test/abc.py
    
 # 绝对路径： c:\user\
    
 # 目录分隔符： Windows：\ Linux和Mac：/
    
 print(os.path.abspath(__file__))  # 获取当前文件的绝对路径
    
 # 判断文件是否存在
    
 os.path.isfile(os.path.abspath(__file__))    # 判断某路径是不是常规的文件,返回True或者False
    
 # 输出当前系统下的目录分割符
    
 print(os.sep)
    
 # 拼接多个路径目录
    
 os.path.join(os.getcwd(), 'def','123') # 拼接当前目录\def\123
    
  
    
 # 返回当前文件所在的绝对路径
    
 os.path.dirname(os.path.abspath(__file__))
    
 # 返回当前文件的文件名（或者目录）
    
 os.path.basename(os.path.abspath(__file__))

 import sys

    
 if __name__ == '__main__':
    
 print("Hello", end=' ')
    
 if len(sys.argv) > 1:
    
 print(' '.join(sys.argv[1:]))
    
  
    
 # sys.argv是个列表
    
 type(sys.argv)
    
 print(sys.argv)