qq_44782285的博客

import socket# HTTP服务器都是基于TCP的 socket 链接server_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)server_socket.bind(('192.168.1.5',9090))server_socket.listen(128)# 获取的数据是一个元组，元组里面有两个元素# 第0个元素是客户端的 socket 链接# 第1个元素是客户端的 IP 地址和 端口号client_sock

# 进程和线程都有 join 方法import timeimport threadingx = 10def test(a,b): time.sleep(1) global x x = a + b# test(1,1)print(x)t = threading.Thread(taeget=test,args=(1,1))t.start()t.join() # join 让主线程等待print(x)...

import multiprocessingimport queueq1 = multiprocessing.Queue() # 进程间通信q2 = queue.Queue() # 线程间通信# 创建队列时，可以指定最大长度，默认是0，表示不限q = multiprocessing.Queue(5)q.put('hello')q.put('world')q.put('python')q.put('java')q.put('github')print(q.full()

import multiprocessingimport timedef dance(m): for i in range(m): time.sleep(0.5) print('正在跳舞')def sing(n): for i in range(n): time.sleep(0.5) print('正在唱歌')if __name__ == '__main__': # target 表示执行的任务

import threadingimport timeimport queuedef produce(): for i in range(10): time.sleep(0.5) print('生产+++++面包{}{}'.format(threading.current_thread().name,i)) q.put('{}{}'.format(threading.current_thread().name,i))def consun

import threadingimport time# 多个线程可以同时操作一个全局变量(多个线程共享全局变量)# 线程安全问题ticket = 20look = threading.Lock()def sell_ticekt(): global ticket while True: lock.acquire() if ticket > 0: time.sleep(0.1) ticket -

import threadingimport time# 多个线程可以同时操作一个全局变量(多个线程共享全局变量)# 线程安全问题ticket = 20def sell_ticekt(): global ticket while True: if ticket > 0: time.sleep(0.1) ticket -= 1 print('{}卖出了一张票，还剩{}张票'.format

import socketimport threadingimport syss = socket.socket(socket.AF_INET,socket.SOCK_STREAM)s.bind(('169.254.50.193',8080))# file = open('chat.txt','w',encoding='utf8')def send_msg(): while True: msg = input('请输入你要发送的内容:') s.sendt

import threading,timedef dance(): for i in range(50): time.sleep(0.2) print('正在跳舞')def sing(): for i in range(50): time.sleep(0.2) print('正在唱歌')# 多个任务同时执行# 多线程，多进程，多线程+多进程# target 需要的是一个函数，用来指定线程需要执行的任务s1 =

文件上传到服务器import socket,ossever_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)sever_socket.bind(('169.254.50.193',9090))sever_socket.listen(128)client_socket,client_addr = sever_socket.accept()data = client_socket.recv(1024).decode('utf8')#

# 贪婪模式:尽可能多的匹配# 非贪婪模式:尽可能少的匹配# 在贪婪模式后面加 ? 可以将贪婪模式转换为非贪婪模式import rem = re.search(r'm.*a','o3rjomjadas')print(m.group())n = re.search(r'm.*?a','o3rjomjadas')print(n.group())# 加号 + 出现一次或多次# 问号 ? 出现0次1或1次...

# 正则表达式的作用是用来对字符串进行检索和替换# 检索:match,search,fullmatch,findall,finditer# 替换:sub 第一个参数是正则表达式,第二个参数是新字符,第三个1参数是需要被替换的import ret = 'afo2d1kf23af245qou3095'print(re.sub(r'\d','x',t))print(re.sub(r'\d+','x',t))p = 'hello34good23'def test(x): y = int

import re# 字母表示它本身,很多字母前面加 \ 会有特殊含义#
表示换行 \t 表示制表符 \s 空白字符 \StopIteration 非空白字符# \d 表示数字 等价于 [0-9] 只能匹配到一个 +加号可以匹配到多个print(re.search(r'x\d+p','x243p'))print(re.search(r'x\dp','x243p'))print(re.search(r'x[0-9]+p','x243p'))# ^ 除了表示以指定内容开始之

import reprint(re.search(r'\s','hello world')) # \s 表示任意的非打印字符print(re.search(r'
','hello
world')) # 换行print(re.search(r'\t','hello\tworld')) # 制表符print(re.search(r'\S', ' \t
xsdcfc')) # \S 表示非空白字符# 标点符号的使用# ():括号用来表示一个分组a = re.search(

import re# 正则修饰符是对正则表达式进行修饰# re.S:让 . 匹配换行# re.I:忽略大小写# re.M 让 $ 能够匹配到换行# . 表示除了换行以外的任意字符x = re.search(r'm.*a','sdmfo
ejoasdl',re.S)print(x)y = re.search(r'x','good Xyz',re.I)print(y)# \w: 表示的是字母，数字和下划线_ +:出现一次以上 $:以指定的内容结尾z = re.findall(r

# 正则表达式 用来处理字符串，查找替换# match 和 search 方法的执行结果是一个Match类型的对象# 在正则表达式里，匹配1个 '\' ，需要使用4个 '\\\\''# 第一个参数是正则匹配规则，第二个参数表示需要匹配的字符串import rex = 'hello\
world'm = re.search('\\\\',x)# 前面可以加一个 r 表示原生字符m = re.search(r'\\',x)print(m)'''查找相关的方法match: 查找字符串

def fiboonacci(n): num1 = num2 = 1 count = 0 while count <= n - 2: num1,num2 = num2,num1 + num2 count += 1 yield num1F = fiboonacci(12) # 此时并不会调用函数for i in F: print(i)结果123581321345589144Process

# 生成器的本质也是一个迭代器x = 5y = 10if x > y: z = xelse: z = yz = x if x > y else y # 三元表达式nums = [i for i in range(10)] # 列表生成式（推导式）print(nums)g = (i for i in range(10)) # 得到的结果是生成器for m in g: # 生成器是一个特殊的迭代器 print(m)# 迭代器是一个对

class Fibonacci(object): def __init__(self,n): self.n = n self.num1 = self.num2 = 1 self.count = 0 def __iter__(self): return self def __next__(self): self.count += 1 if self.count <= self.n:

from collections.abc import Iterableclass Demo(object): def __init__(self,x): self.x = x self.count = 0 def __iter__(self): # 只要重写了 __iter__ 方法就是一个可迭代对象 # f = Foo() return self def __next__(self): #

# 可迭代对象: list tuple dict set str range filter map# for...in 可迭代对象# for...in 循环的本质就是调用可迭代对象的 __iter__ 方法，获取到这个方法的返回值# 这个返回值需要一个对象，然后再调用这个对象的 __next__ 方法from collections.abc import Iterable# class Foo(object):# def __next__(self):# retu

"""名片管理系统：1.添加名片2.删除名片3.修改名片4.查询名片5.显示所有名片6.推出系统"""user_list = []def add_user(): # 让用户输入信息 name = input('请输入用户名:') # 当用户输入用户名后，查询列表，看用户是已经存在 for u in user_list: if u['name'] == name: print('用户名已存在')

def can_play(clock): print('最外层函数被调用了，clock = {}'.format(clock)) def handle_action(fn): print('handle_action被调用了') def do_action(name,game): if clock < 21: fn(name,game) else:

# with 语句后面的结果对象，需要重写 __enter__ 和 __exit__方法# 当进入到 with 代码块时，会自动调用 __enter__ 方法里的代码# 当 with 代码块执行完成以后，会自动调用 __exit__ 方法class Demo(object): def __enter__(self): print('__enter__方法被执行了') return self def __exit__(self, exc_type, ex

def test(a,b): x = a + b return x # 一旦出现 return 就表示函数结束 return 'hello' # 这段代码不会被执行，一般情况下，一个函数最多只能执行一个return语句def demo(a,b): try: x = a / b except ZeroDivisionError: return '除数不能为0' else: return x fi

# 求绝对值a = abs(-6)print(a)# 元素都为真返回True，反之返回Falseb = all([1,2,5,4,6,0,7,8,])print(b)# 元素至少一个为真返回True，否则返回Falsec = any([1,2,5,4,6,0,7,8,])print(c)# 定义元组时,()括号也可以省略，元素之间用逗号隔开d = 1,2,3,4,5,6,print(d)print(type(d))# 当元组里面只有一个元素时，逗号也不能省略e1 = (5)

# 在程序运行过程中，由于某种原因导致程序无法正常执行def div(a,b): return a / btry: x = div(5,0) print('hahaha')except Exception as e: print('程序出错了！！！')else: print('程序没有问题')# try...except 语句用来处理程序运行中的异常...

# Python里存入数据只支持存入 字符串 和 二进制# json:将Python里的数据(str/list/tuple/dict/int/float/bool/None)等转换为对应的json类型1# pickle:将Python里任意的对象转换成二进制import pickle# 序列化: dump:将Python数据转换为二进制同时保存到指定文件# dumps：将Python数据转换为二进制# 反序列化:load:读取文件并将文件的二进制内容加载成为Python数据

# 序列化:将数据从内存持久化保存到硬盘的过程# 反序列化:将数据从硬盘加载到内存的过程# write时，只能写入字符串或二进制，字典，列表，数字等都不能直接写入到文件里# 写入方法：# 可以将数据转换成二进制或字符串写入 repr/str() json模块 pickle模块# json 本质就是字符串import jsonfile = open('xxx.txt','w',encoding='utf8')names = ['zhangsan','lisi','wangwu','cu

import sys# sys.stdin 接收用户的输入，读取键盘里的数据# sys.stdout 标准输出# sys.stderr 错误输出s_in = sys.stdin # input就是读取sys.stdin里的数据while True: content = s_in.readline().rstrip('
') if content == '': break print(content)sys.stdout = open('stdo

from io import StringIO,BytesIOs_io = StringIO()s_io.write('Hello ') #把数据写入到内存里缓存s_io.write('Python')print(s_io.getvalue())s = ''s += 'hello's += 'world'print(s)print('hello',file=open('xxx.txt','w')) # file是一个文件流对象print('good',file=s_i

import csvfile = open('demo.csv','w',encoding='utf8',newline='')w = csv.writer(file)w.writerow(['name','age','score','city'])# w.writerow(['张三','20','100','上海'])# w.writerow(['李四','22','100','武汉'])# w.writerow(['王五','25','100','北京'])w.writerows(

import osfile_name = input('请输入一个文件路径：')if os.path.isfile(file_name): # 判断是否是文件 # 打开旧文件 old_file = open(file_name,encoding='utf8') names = os.path.splitext(file_name) new_file_name = names[0] + '.bak' + names[1] new_file = open(new_

在这里插入代码片# 在windows里默认gbK编码# mode 指的是文件的打开方式# r 只读模式，是默认值，只能读取，不能写入# w 写入模式，打开文件后只能写入，不能读取,如果文件存在，会覆盖文件，如果文件不存在，会创建文件# b 以二进制的形式打开文件,用来操作非文本文件# rb 以二进制读取 wb 以二进制写入# a 追加模式，会在最后追加内容。如果文件不存在，会建文件，如果文件存在，会追加# r+ 可读写 如果文件不存在会报错# w+ 可读写 如果文件不存在，会创建文件；

"""绝对路径相对路径：../上一级1文件夹 ./当前文件夹"""import osprint(os.name)print(os.sep) # 在windows系统里，文件夹之间使用 \ 分隔# 在Python的字符串里，\ 表示转义字符# file = open('C:\Users\TR\Desktop\Python教程2020版代码\xxx.txt') 会报错"""文件名路径的三种方法：1.两个反斜杠\\2.转义字符 r3./ 斜杠"""file1 = open(

# Python里使用内置函数 open 打开并操作一个文件"""open 参数介绍：file:用来指定打开的1文件(不是文件的名字1，而是文件的路径)mode:打开1文件的模式，默认是 r ,表示只读encoding:打开文件时的编码方式open函数会有一个返回值，打开的文件对象写入和读取的编码要一致操作完成文件后要关闭"""file = open('xxx.txt',encoding ='utf8')print(file.read())file.close()结果人生苦短，

# 继承特点：如果一个类A继承自类B，由类A创建出来的实例对象都能直接使用类B里定义的方法class Person(object): def __init__(self,name,age): self.name = name self.age = age def sleep(self): print(self.name + '正在睡觉')class Student(Person): def __init__(self,name,ag

"""新式类：继承自 object 的类经典类：不继承自 object 的类"""class Student(object): # 手动指定 Student 类继承自 object passclass Dog: # 没有指定 Dog 的父类，python3里默认1继承自 object passs = Student()d = Dog()...

class Animal(object): def __init__(self,name,age): self.name = name self.age = age self.__money = 1000 def eat(self): print(self.name + '正在吃东西') def __test(self): print('我是Animal里的__test方法')class Person

class Animal(object): def __init__(self, name, age): self.name = name self.age = age def sleep(self): print(self.name + '正在睡觉')class Dog(Animal): # def __init__(self,name,age): # self.name = name # self.

# 定义一个类属性，记录通过这个类创建了多少个对象class Person(object): count = 0 def __new__(cls, *args, **kwargs): cls.count += 1 x = object.__new__(cls) #申请内存，创建一个对象，并设置类型是Person类 return x def __init__(self,name,age): # Person.co

class Person(object): def __init__(self,name,age): self.name = name self.age = age def eat(self,food): #对象方法有一个参数self，指的是实例对象 print(self.name + '正在吃' + food) #如果一个方法里没有用到实例对象的任何属性，可以将这个方法定义为satic @staticmethod

import datetimeclass Person(object): def __init__(self,name,age): self.name = name self.age = age self.__money = 1000 #以两个下划线 __ 开始的变量是私有变量 def get_money(self): print('{}查询了余额'.format(datetime.datetime.now()))

class Person(object): type = '人类' #这个属性定义在类里，函数之外，我们称之为类属性 def __init__(self,name,age): self.name = name self.age = age"""对象p1，p2都是通过Person类创建出来的实例对象name和age是对象属性，是每一个实例对象都会单独保存一份的属性每个实例对象之间的属性没有关联，互不影响"""p1 = Person('张三',

class Person(object): __slots__ = ('name','age') #规定了这个对象能够出现的属性 def __init__(self,name,age): self.name = name self.age = age def eat(self): print(self.name + '正在吃饭')p = Person('张三',18)print(dir(p))print(p.__class__)

"""1.不需要手动调用，会在合适的时机自动调用2.这些方法都是以__开始，以__结束3.方法名都是系统规定的，在合适的时机自己调用"""class Person(object): def __init__(self,name,age): #在创建对象时会自动调用这个方法 print('__init__方法被调用了') self.name = name self.age = age def __del__(self):

class Student(object): # __slots__ = ('name','age','city') 这个属性直接定义在类里，是一个元组，用来规定对象可以存在的属性 # def __new__(cls, *args, **kwargs): def __init__(self,x,y): self.name = x self.age = y def say_hello(self): print('大家好，我是',

import hashlibimport hmac#这两个模块都是用来密码加密的#hashslib模块支持md5和sha两个算法加密"""加密方式：1.单向加密-只有加密的过程，不能解密2.对称加密3.非对称加密"""x = hashlib.md5() #生成一个md5对象x.update('abc'.encode('utf8'))print(x.hexdigest())*******************************************import uui

#在python中，一个py文件就是一个模块"""1.import time 使用 import 模块名 直接导入一个模块2.from random import randint 导入一个模块里的方法或者变量3.from math import * 导入这个模块里的”所有“方法和变量4.import datetime as dt 导入一个模块并给这个模块取一个别名5.from copy import deepcopy as dp from 模块名 import 函数名 as

import time#代码运行之前获取当前时间start = time.time()print('代码运行前的时间为:',start)x = 0for i in range(1,100000000): x += iprint(x)#代码运行完之后，再次获取一下时间end = time.time()print('代码执行完成后的时间为:{}秒'.format(end - start))print('****************************************

"""1.一个函数作为另一个函数的返回值2.一个函数作为另一个函数的参数3.函数内部在定义一个函数"""def hanshu1(): print('我是函数1') return 'hello'def hanshu2(): print('我是函数2') return hanshu1def demo(): print('我是demo函数') return hanshu1()a = demo() #执行demo函数，并把demo函数执行的结

print(abs(-20)) #abs取绝对值print(all('hello ,world')) #all如果所有的元素转换成布尔值都是true，结果是True，否则就是falseprint(all([1,2,3,4,5,6]))print(all([0]))print(any('hello')) #any只要有一个元素转换成布尔值是true，结果是True，否则就是falseprint(any([0,1,2,3,]))print(bin(546261)

#filter 对可迭代对象进行过滤，得到的是一个fliter对象，filter对象也是一个可迭代对象ages = [12,15,32,46,23,15,46,30,15,17]#filter可以给定两个参数，第一个参数是函数，第二个参数是可迭代对象x = filter(lambda ele:ele > 18,ages)print(x)for a in x: print(a)#可迭代对象可以循环遍历adult = list(x)print(adult)"""#########

nums = [23,47,96,41,56,8,9,46,1,3,2,5]#列表的sort方法会直接对列表进行排序nums.sort()print(nums)#sorted内置函数，不改变原有的数据，而是生成一个新的有序的列表nums1 = [23,47,99,41,6,8,9,46,1,3,2,5]nums2 = (20,7,96,41,56,8,9,16,1,3,2,5) #元组是不可变的，此时会生成一个新的有序的列表x1 = sorted(nums1)x2 = sorted(

def test(a,b): x = a // b y = a % b #一般情况下，一个函数最多只会执行一个return语句 #特殊情况下(finally语句)下，一个函数会执行多个return语句 #一个return可以返回多个值，将多个值放到一个整体里面去 容器 return x,y #return语句表示一个函数的结束 #return y #第一个之后的return语句将不会再执行 #return x,y 返回的本质就是一个

#say_hello(city = 'China',name,age): 缺省参数要放在后面def say_hello(name,age,city = 'China'): #形参city给了一个默认值 print('大家好，我叫{},我今年{}岁了，我来自{}'.format(name,age,city))say_hello('Curry',32,'China') #如果没有传递参数，会使用默认值#如果有位置参数和关键字参数，关键字参数一定要放在位置参数的后面say_h...

def add(a,b): return a + bdef add_many(item): x = 0 for n in item: x += n return x# num = [1,2,3,4,5,6,7,8,9]# print(add(num))# print(add((1,2,3,4,6,7,9,5,1,2,8,4)))# print(add_many({4,3,6,8,9,1,2,7,5}))# print(add_many(range(

def test(a): print('修改前a的内存地址0x%x'%id(a)) a = 100 print('修改后a的内存地址0x%x' % id(a))def demo(nums): print('修改前nums的内存地址0x%x' % id(nums)) nums[0] = 10 print('修改后nums的内存地址0x%x' % id(nums))...

#递归函数本质就是函数内部自己调用自己#递归函数最重要的就是找到出口（终止的条件）count = 0 #定义一个全局变量def tell_story(): global count count += 1 print('从前有座山') print('山上有座庙') print('庙里有个老和尚') print('还有一个小和尚') print('老和尚在给小和尚讲故事') print('故事是这样的') if count

#匿名函数unname = lambda a,b:a*bprint(unname(4,5))"""调用方法1.给他定义一个变量名2.把这个函数当作参数传给另一个函数使用"""#回调函数：把一个函数当作另一个函数的参数def calc(a,b,fn): c = fn(a,b) return c"""def add(x,y): return x + ydef minus(x,y): return x - yx1 = calc(1,2,add)prin

a = 100 #这个变量是全局变量，在整个py文件里都可以访问world = 'hello'def test(): x = 'hi' #这个变量是在函数内部定义的变量，是局部变量，只能在函数内部使用 print('x = {}'.format(x)) #如果局部变量的名和全局变量同名，会在函数内部又定义一个新的局部变量，而不是修改全局变量 a = 10 print('函数内部a = {}'.format(a)) #函数内部如果想要修改全局

"""def function_name(形参1，形参2，形参3...): 形参只是用来占位的，函数调用时传入的参数才是真正的参数 执行的语句 return 函数的返回值就是执行的结果，不是所有的函数都必须要有返回值 function_name(实参1，实参3，实参3...) 函数调用时传入的参数时实参"""def tell_story(place,person1,person2): print('从前有座山') print('山上有座

#eval可以执行字符串里的代码a = "input('请输入一个数字:') "print(eval(a))b = '1+6'print(eval(b))#json是一个轻量级的数据交换格式，本质是一个字符串，可以把列表，元组，字典等转换为json格式的字符串#json里的字符串只能用双引号""import jsonJson = '{"name":"curry","sex":"male","age":"30","tel":"123456789","score":"100"}'x = js

#集合：不重复，无序 可以使用{}或者set来表示#{}有两种意思：字典，集合#{}里如果放的是键值对，它就是一个字典;如果{}里放的是单个的值，它就是一个集合#set{}表示一个空集合，{}表示一个空字典person = {'name':'curry','age':18} #字典person1 = {'name','curry','age',30} #集合names = {'zhangsan','lisi','jack','tom','curry'}print(names

#元组之间支持加法“+”运算#使用集合set可以去重"""用三个元组表示三门学科的选课学生姓名（一个学生可以同时选多门课）1.求选课学生共有多少人2.求只选了lessson1学科人的数量和对应的名字3.求只选了1门学科的学生的人数和对应的名字4.求只选了2门学科的学生的人数和对应的名字5.求选了3门学科的学生的人数和对应的名字"""lesson1 = ('王昭君','妲己','貂蝉','吕布','孙悟空','韩信','凯','大乔','小乔','鬼谷子',)lesson2 = ('诸葛

chars = ['a','c','d','s','a','c','d','s','c']char_count = {}for char in chars: if char in char_count: char_count[char] += 1 else: char_count[char] = 1 #if char not in char_count: #char_count[char] = charss.count(char)

#列表可以使用extend方法将两个列表合并成为一个列表num1 = [1,2,3,4,5]num2 = [6,7,8,9]num1.extend(num2)print(num1)print(num1+num2)word1 = ('hello','world')word2 = ('python','java')print(word1+word2)person1 = {'name':'curry','hobby':'basketball'}person2 = {'number':30,

#1.for-in循环字典person = {'name':'Curry','age':'32','number':'30','hobby':'basketball'}for i in person: print(i,'=',person[i])#2.获取所有的key，然后再遍历key，根据key获取valueprint(person.keys())for k in person.keys(): print(k,'=',person[k])#3.只能获取到value，不能拿到

#使用一对大括号来表示一个字典{}#由一对对键值对组成#字典名 = {键:值} dic_name = {key:value}#有多个键值对时用逗号','来隔开#字典里的key不允许重复，键是唯一的，值value可以是任意数据类型#key只能是不可变数据类型 一般使用字符串introduce = {'name':'Curry', 'hobby':'basketball', 'weigh':'60kg', 'he

#使用一对小括号()来表示一个元组#元组是不可变数据类型，不能进行增删改操作#和列表一样，也是一个有序的存储数据的容器#可以通过下标来获取元素#列表是可变的，而元组是不可变的数据类型words = ['hello','world','python']nums = (5,3,4,3,8,6,1,4,2,0,6,7,9,4,5,9,4,3,7,9)print(nums[3])print(nums.index(7))print(nums.count(9))age = (30) #age

num = [i for i in range(10)]print(num)num1 = []for i in range(10): num1.append(i)print(num1)points = [(x,y) for x in range(5,9) for y in range(10,20)]print(points)##################m = [i for i in range(1,101)]print(m)n = [m[j:j+3] for j i

#一个学校有10个老师，3个待分配的办公室import randomteachers = ['A','B','C','D','E','F','G','H','I','J']rooms = [[],[],[]]for teacher in teachers: room = random.choice(rooms) room.append(teacher)print(rooms)for i ,room in enumerate(rooms): print('房间%d里一共有

#冒泡排序#让一个数字和它相邻的下一个数字进行比较，如果前一个数字大于后一个数字，交换两个数据的位置num = [6,5,3,1,8,7,2,9,4]i = 0while i < len(num) - 1: #i = 9 i += 1 n = 0 while n < len(num) - 1: if num[n] > num[n + 1]: num[n],num[n+1] = num[n+1],num[n]

#1.借助第三方变量a = 10b = 20c = bb = aa = cprint(a)print(b)#2.使用运算符来实现，只能是数字a = 30b = 40a = a + bb = a - ba = a - bprint(a)print(b)#3.使用异或运算符a = 50b = 60a = a ^ bb = a ^ ba = a ^ bprint(a)print(b)#4.a = 70b = 80a , b = b ,aprint(a)

#遍历：将所有的数据都i访问一遍 遍历针对的是可迭代对象#while for-in 循环#for 变量 in 可迭代对象#for循环的本质就是不断地调用迭代器的next方法查找下一个数据fashi = ['王昭君','妲己','貂蝉','安琪拉','甄姬','鬼谷子']for fs in fashi: print(fs)i = 0while i < len(fashi): print(fashi[i]) i += 1结果王昭君妲己貂蝉安琪

#用[]中括号表示列表，列表里的数据称为元素，用“,”英文的逗号来分割#列表里的元素可以修改#列表用来存储多个数据#对列表的增删改查#添加元素的方法 append insert extend#append 在列表元素的最后面追加一个数据#insert(index,object)#extend 需要一个可迭代对象 A.extend(B) 将可迭代对象B添加到A里wzry1 = ['孙悟空','王昭君','大乔','貂蝉','西施','凯']wzry1.append('李白')print(w

print('hello world'.capitalize()) #让第一个单词首字母大写print('hello world'.upper()) #全大写print('hello world'.lower()) #全小写print('hello world'.title()) #每个单词的首字母大写#ljust,rjust ljust(width,fillchar) 长度和填充的字符，默认是空格print('hello'.ljust(10)

#根据输入的百分制成绩打印‘及格’或者‘不及格’，60分以下为不及格score = float(input('请输入你的成绩:'))if score < 60: print('不及格')else: print('恭喜你，及格了')#根据输入的年龄打印‘成年’或者‘未成年’。18岁以下为未成年，如果年龄不在正常范围内（0-150）则打印‘这不是人’age = int(input('请输入你的年龄:'))if 150 > age > 0: if age &

# 字符串是不可变数据类型！！！a = 'Curry'b = "Kobe"c = '''Stephen'''d = """Bryant"""# \' 显示一个普通的单引号# \" 显示一个普通的双引号#
换行# \t 制表符，4个空格# \\ 前面一个\是对后面\的转义,一个普通的\print('hello wor\\ld')# 在字符串前面添加一个r/R,表示原生字符串p = r'hello \teacher'print(p)p = 'hello \teac

#根据输入的百分制成绩打印‘及格’或者‘不及格’，60分以下为不及格score = float(input('请输入你的成绩:'))if score < 60: print('不及格')else: print('恭喜你，及格了')#根据输入的年龄打印‘成年’或者‘未成年’。18岁以下为未成年，如果年龄不在正常范围内（0-150）则打印‘这不是人’age = int(input('请输入你的年龄:'))if 150 > age > 0: if age &

i = 0while i < 5: print('*'*5,end='
') i += 1i = 0while i < 5: i += 1 print(i*'*')i = 0while i < 10: #外循环用来控制行数 i += 1 j = 0 while j < 10: ##内循环用来控制每一行的列数 j += 1 print('*',end=' ')

#break和continue只能用于循环语句中#break 用来结束整个循环#continue 用来结束本轮循环，开启下一轮循环i = 0while i < 5: if i == 3: i += 1 break #continue print(i) i += 1answer = input('我爱你，你爱我吗？')while answer != '爱': answer = input('我爱你，你爱我吗？')wh

#for 变量名字 in 可迭代对象#range 是一个内置类，用来生成指定区间的整数序列#in的后面必须是一个可迭代对象#str,list,dict,tuple,set,range都是可迭代对象for i in range(1,11): print(i)for x in [1,2,3,4,5,6,7,8,9] : pritn(x)for z in 'hello world': print(z)...

#循环就是让一件事重复做多次#Python里的循环分为 while 循环和 for 循环#while循环的基本使用#while 判断条件:# 条件成立执行的语句#while循环语句分为3步：先判断条件是否成立，执行成立时的语句，再判断条件x = 0while x < 10: print('hello world') x += 1#python里没有自增自减运算符 x++ x--#求1-100所有整数之和i = 0result = 0 #定

num1 = int(input('请输入一个数字:'))num2 = int(input('请再输入一个数字:'))# if num1 > num2:# x = num1# else:# x = num2# print('两个数中最大的是:',x)x = num1 if num1>num2 else num2 #一行代码print('两个数中最大的是:',x)...

import random#random 函数，导入随机数#random.randint(a,b) 生成[a,b]的随机整数player = int(input('请输入 (0)剪刀 (1)石头 (2)布'))print('用户输入的是',player)computer = random.randint(0,2)print('电脑出的是',computer)if (player == 0 and computer == 2) or (player == 1 and computer ==

#if语句的嵌套ticket = input('是否买票了？ Y/N')if ticket == 'Y': print('买票了，可以进站') safe = input('安检是否通过？Y/N') if safe == 'Y': print('安检通过了，可以进入候车室') else: print('进站了，但安检未通过')else: print('没有买票，滚蛋')##############################

score = float(input('请输入你的分数'))if 60 > score > 0: print('你个垃圾')if 80 > score >= 60: print('一般般')if 90 > score >= 80: print('还不错')if 100 >= score >= 90: print('很棒棒')#if-elif-elif...-elsescore = float(input('请输入

条件判断语句1.if2.if else3.if elif elif…else字符串和数字做比较运算规则：==结果是False， !=结果是True，其他比较运算会报错age = int(input('请输入你的年龄：'))if age < 18: print('未满18岁，禁止入内')else: print('性感荷官在线发牌')if...else语句if 判断条件: 条件成立时执行的代码else: if的条件不成立时执行的代码num = int

按位与& 同1则为1，否则为0#按位或| 只要有一个为1，结果就为1#按位异或^ 相同为0，不同为1#按位左移<<#按位右移>>#按位取反~a = 23 #0001 0111 23b = 15 #0000 1111 15 #0000 0111 7#0001 1000 24 #0001 1111 31print(a & b)print(a | b)print(a ^ b)x = 5

Python自学笔记之前学习的没有做笔记，从2020-10-18开始做的笔记字典：字典名 = {‘键’：’值‘}dic_name = {‘keys’:‘values’}删除键值对： del 字典名[‘键’]遍历所有的键值对： for keys,values in 字典名.items():遍历所有的键： for key in 字典名.keys():key为变量，存储遍历的键。for循环提取字典中的所有键并存储到变量（key）中 。.keys():可以省略。遍历字典时，会默认遍历