奥运五环python代码参考_奥运五环用python的代码

奥运五环python代码参考_奥运五环用python的代码

       好久不见了，今天我想和大家探讨一下关于“奥运五环python代码参考”的话题。如果你对这个领域还不太了解，那么这篇文章就是为你准备的，让我们一起来学习一下吧。

1.python基础代码是什么?

2.python编程，求这两道题的代码

3.python基础代码是什么？

4.请问一下网友老铁们 美国国旗用python怎么做呀 求其代码 谢谢拉

5.求Python大神给个200行左右的代码，多点注释，做期末大作业

6.求一个编写的五子棋小游戏python的代码，求借鉴啊！！急急急。。。

python基础代码是什么?

       python入门代码是：

       defnot_empty（s）：

       returnsandlen（s。strip（））>0

       #returnsands。strip（）

       #如果直接单写s。strip（）那么s如果是None，会报错，因为None没有strip方法。

       #如果s是None，那么Noneand任何值都是False，直接返回false

       #如果s非None，那么判定s。trip（）是否为空。

       这样子filter能过滤到None，""，""这样的值。

       分成两部分看。第一部分是对长度进行序列。相当于就是range(5)他的结果就是。01234。第二部分就是具体的排序规则。排序规则是用nums的值进行排序，reverse没申明就是默认升序。就是用nums(0到4)的值进行排序，根据这个结果返回的一个range(5)的数组。

基本语法：

       Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。它不像其他的静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和意外。

python编程，求这两道题的代码

       百度知道

       Python高难度代码例子、Python最复杂代码例子

       张三讲法

       TA获得超过3912个赞

       关注

       成为第46位粉丝

       #IT教育# #IT# #程序员# #人工智能#

       最近学习pytorch，看到下面的Python高难度代码例子和Python最复杂代码例子：

       from google.colab import output as colab_output

       from base64 import b64decode

       from io import BytesIO

       from pydub import AudioSegment

       RECORD = """

       const sleep = time => new Promise(resolve => setTimeout(resolve, time))

       const b2text = blob => new Promise(resolve => {

       const reader = new FileReader()

       reader.onloadend = e => resolve(e.srcElement.result)

       reader.readAsDataURL(blob)

       })

       var record = time => new Promise(async resolve => {

       stream = await navigator.mediaDevices.getUserMedia({ audio: true })

       recorder = new MediaRecorder(stream)

       chunks = []

       recorder.ondataavailable = e => chunks.push(e.data)

       recorder.start()

       await sleep(time)

       recorder.onstop = async ()=>{

       blob = new Blob(chunks)

       text = await b2text(blob)

       resolve(text)

       }

       recorder.stop()

       })

       """

       def record(seconds=1):

       display(ipd.Javascript(RECORD))

       print(f"Recording started for {seconds} seconds.")

       s = colab_output.eval_js("record(%d)" % (seconds * 1000))

       print("Recording ended.")

       b = b64decode(s.split(",")[1])

       fileformat = "wav"

       filename = f"_audio.{fileformat}"

       AudioSegment.from_file(BytesIO(b)).export(filename, format=fileformat)

       return torchaudio.load(filename)

       waveform, sample_rate = record()

       print(f"Predicted: {predict(waveform)}.")

       ipd.Audio(waveform.numpy(), rate=sample_rate)

       js 的Promise函数对象编程，字符串javascript函数对象，IPython解释js对象，解释结果和python代码结合，IPython Shell显示非字符串数据，python音频使用IPython简单调用。

       复杂Python模块下的多知识点结合代码，是Python高难度代码的体现。

       Js的Promise理解为动态函数，比C++的类成员函数和全局函数这类静态形式的函数处理灵活，不过初学者理解起来麻烦。代码里sleep和b2text都代表一些处理函数，也就是几行代码，而不是数据。通常来讲，变量一般代表数据，但是这里代表了指令。

python基础代码是什么？

       #?coding:UTF-8

       n=int(input())

       s=0.0

       sign=-1.0

       for?i?in?range(1,n+1):

        sign=-sign

        s=s+1.0/i*sign

       print(s)

       n=int(input())

       for?k?in?range(1,n+1):

        for?i?in?range(k,n+1):

        print(i,'?',end='')

        for?i?in?range(1,k):

        print(i,'?',end='')

        print()

请问一下网友老铁们 美国国旗用python怎么做呀 求其代码 谢谢拉

       代码：

       defnot_empty（s）：

       returnsandlen（s。strip（））>0

       #returnsands。strip（）

       #如果直接单写s。strip（）那么s如果是None，会报错，因为None没有strip方法。

       #如果s是None，那么Noneand任何值都是False，直接返回false

       #如果s非None，那么判定s。trip（）是否为空。

       这样子filter能过滤到None，""，""这样的值。

       分成两部分看。第一部分是对长度进行序列。相当于就是range(5)他的结果就是。01234。第二部分就是具体的排序规则。

       排序规则是用nums的值进行排序，reverse没申明就是默认升序。就是用nums(0到4)的值进行排序，根据这个结果返回的一个range(5)的数组。

PEP的规定：

       必须使用4个空格来表示每级缩进。使用Tab字符和其它数目的空格虽然都可以编译通过，但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为兼容很旧的的Python程序和某些有问题的编辑程序。

       Python的函数支持递归、默认参数值、可变参数，但不支持函数重载。为了增强代码的可读性，可以在函数后书写“文档字符串”(Documentation Strings，或者简称docstrings)。

       用于解释函数的作用、参数的类型与意义、返回值类型与取值范围等。可以使用内置函数help()打印出函数的使用帮助。

求Python大神给个200行左右的代码，多点注释，做期末大作业

       参考下五星红旗

       <code>#!/usr/bin/env python

       # -*- coding: utf-8 –*-

       ''' 对于turtle类的一些封装方法，包括画正多边形，正多角形和五星红旗。'''

       __author__ = 'Hu Wenchao'

       import turtle

       import math

       def draw_polygon(aTurtle, size=50, n=3):

        ''' 绘制正多边形

        args:

        aTurtle: turtle对象实例

        size: int类型，正多边形的边长

        n: int类型，是几边形

        '''

        for i in xrange(n):

        aTurtle.forward(size)

        aTurtle.left(360.0/n)

       def draw_n_angle(aTurtle, size=50, num=5, color=None):

        ''' 绘制正n角形，默认为**

        args:

        aTurtle: turtle对象实例

        size: int类型，正多角形的边长

        n: int类型，是几角形

        color: str， 图形颜色，默认不填色

        '''

        if color:

        aTurtle.begin_fill()

        aTurtle.fillcolor(color)

        for i in xrange(num):

        aTurtle.forward(size)

        aTurtle.left(360.0/num)

        aTurtle.forward(size)

        aTurtle.right(2*360.0/num)

        if color:

        aTurtle.end_fill()

       def draw_5_angle(aTurtle=None, start_pos=(0,0), end_pos=(0,10), radius=100, color=None):

        ''' 根据起始位置、结束位置和外接圆半径画五角星

        args:

        aTurtle: turtle对象实例

        start_pos: int的二元tuple，要画的五角星的外接圆圆心

        end_pos: int的二元tuple，圆心指向的位置坐标点

        radius: 五角星外接圆半径

        color: str， 图形颜色，默认不填色

        '''

        aTurtle = aTurtle or turtle.Turtle()

        size = radius * math.sin(math.pi/5)/math.sin(math.pi*2/5)

        aTurtle.left(math.degrees(math.atan2(end_pos[1]-start_pos[1], end_pos[0]-start_pos[0])))

        aTurtle.penup()

        aTurtle.goto(start_pos)

        aTurtle.fd(radius)

        aTurtle.pendown()

        aTurtle.right(math.degrees(math.pi*9/10))

        draw_n_angle(aTurtle, size, 5, color)

       def draw_5_star_flag(times=20.0):

        ''' 绘制五星红旗

        args:

        times: 五星红旗的规格为30*20， times为倍数，默认大小为10倍， 即300*200

        '''

        width, height = 30*times, 20*times

        # 初始化屏幕和海龟

        window = turtle.Screen()

        aTurtle = turtle.Turtle()

        aTurtle.hideturtle()

        aTurtle.speed(10)

        # 画红旗

        aTurtle.penup()

        aTurtle.goto(-width/2, height/2)

        aTurtle.pendown()

        aTurtle.begin_fill()

        aTurtle.fillcolor('red')

        aTurtle.fd(width)

        aTurtle.right(90)

        aTurtle.fd(height)

        aTurtle.right(90)

        aTurtle.fd(width)

        aTurtle.right(90)

        aTurtle.fd(height)

        aTurtle.right(90)

        aTurtle.end_fill()

        # 画大星星

        draw_5_angle(aTurtle, start_pos=(-10*times, 5*times), end_pos=(-10*times, 8*times), radius=3*times, color='yellow')

        # 画四个小星星

        stars_start_pos = [(-5, 8), (-3, 6), (-3, 3), (-5, 1)]

        for pos in stars_start_pos:

        draw_5_angle(aTurtle, start_pos=(pos[0]*times, pos[1]*times), end_pos=(-10*times, 5*times), radius=1*times, color='yellow')

        # 点击关闭窗口

        window.exitonclick()

       if __name__ == '__main__':

        draw_5_star_flag()

       </code>

求一个编写的五子棋小游戏python的代码，求借鉴啊！！急急急。。。

       #-*-?coding:utf-8?-*-

       import?curses?#引入curses模块，curses是一个在Linux/Unix下广泛应用的图形函数库.，作用是可以绘制在DOS下的用户界面和漂亮的图形。

       from?random?import?randrange,?choice?#?从random模块引入randrange,choice这两个类

       from?collections?import?defaultdict?#从collections引入defaultdict这个类

       letter_codes?=?[ord(ch)?for?ch?in?'WASDRQwasdrq']?#ord函数是把字符转换成对应的数字

       actions?=?['Up',?'Left',?'Down',?'Right',?'Restart',?'Exit']?#上，左，下，右，重启，退出

       actions_dict?=?dict(zip(letter_codes,?actions?*?2))?#把字母与动作对应起来。?zip是把元组中的值对应起来。

       #############################

       W?Up

       A?Left

       S?Down

       D?Right

       R?Restart

       Q?Exit

       w?Up

       a?Left

       s?Down

       d?Right

       r?Restart

       Q?Exit

       ##############################################?

       def?get_user_action(keyboard):

       char?=?"N"?#char的初始值为Nwhile?char?not?in?actions_dict:

       char?=?keyboard.getch()return?actions_dict[char]?#阻塞＋循环，直到获得用户有效输入才返回对应行为def?transpose(field):return?[list(row)?for?row?in?zip(*field)]?#zip函数里边加*号，是把行变列，列变行。所以这句代码是行列转置def?invert(field):return?[row[::-1]?for?row?in?field]?#这句代码是把列表前后颠倒class?GameField(object):?#创建一个叫做GameField的类，用来创建棋盘def?__init__(self,?height=4,?width=4,?win=2048):?这个类三个参数self.height?=?height?#高self.width?=?width?#宽self.win_value?=?win#过关分数self.score?=?0#当前分数self.highscore?=?0#最高分self.reset()#重置棋盘def?reset(self):#定义一个reset函数if?self.score?>?self.highscore:#如果当前分数大于最高分，那么把当前分数赋值给最高分self.highscore?=?self.scoreself.score?=?0#当前分数恢复到0分self.field?=?[[0?for?i?in?range(self.width)]?for?j?in?range(self.height)]#横纵坐标恢复到（0,0）self.spawn()#调用spawn这个函数self.spawn()def?move(self,?direction):#定义move函数def?move_row_left(row):#向左移def?tighten(row):?#?squeese?non-zero?elements?together?把零散的非零单元挤到一块

       new_row?=?[i?for?i?in?row?if?i?!=?0]?#如果i不等于零，把他们赋值到new_row这个元组中

       new_row?+=?[0?for?i?in?range(len(row)?-?len(new_row))]#其余位置用0补充return?new_row#返回这个元组def?merge(row):#定义merge函数，用来合并单元

       pair?=?False#pair初始值为假

       new_row?=?[]#new_row初始值为空for?i?in?range(len(row)):#让i在格子里循环if?pair:如果pair为真

       new_row.append(2?*?row[i])#那么把把rowi的值乘以2，追加到new_row后边self.score?+=?2?*?row[i]#并且得分为rowi的值乘以2

       pair?=?False#pair重新赋值为假else:如果pair为真if?i?+?1?<?len(row)?and?row[i]?==?row[i?+?1]:#如果i+1还没到边界，并且此时的rowi=rowi+1

       pair?=?True?#那么pair为真

       new_row.append(0)#new_row后追加零else:

       new_row.append(row[i])#否则追加rowi

       assert?len(new_row)?==?len(row)?#提醒两者长度一致return?new_rowreturn?tighten(merge(tighten(row)))?#反复合并，知道不能合并为止

       moves?=?{}

       moves['Left']?=?lambda?field:?\

       [move_row_left(row)?for?row?in?field]#做移动

       moves['Right']?=?lambda?field:?\

       invert(moves['Left'](invert(field)))#invert是逆转

       moves['Up']=?lambda?field:?\

       transpose(moves['Left'](transpose(field)))#transpose是转置

       moves['Down']?=?lambda?field:?\

       transpose(moves['Right'](transpose(field)))if?direction?in?moves:if?self.move_is_possible(direction):#如果移动方向在四个方向上，self.field?=?moves[direction](self.field)那么调用moves函数self.spawn()#产生随机数return?Trueelse:return?Falsedef?is_win(self):return?any(any(i?>=?self.win_value?for?i?in?row)?for?row?in?self.field)def?is_gameover(self):return?not?any(self.move_is_possible(move)?for?move?in?actions)def?draw(self,?screen):

       help_string1?=?'(W)Up?(S)Down?(A)Left?(D)Right'

       help_string2?=?'?(R)Restart?(Q)Exit'

       gameover_string?=?'GAME?OVER'

       win_string?=?'?YOU?WIN!'def?cast(string):

       screen.addstr(string?+?'\n')def?draw_hor_separator():

       line?=?'+'?+?('+------'?*?self.width?+?'+')[1:]

       separator?=?defaultdict(lambda:?line)if?not?hasattr(draw_hor_separator,?"counter"):

       draw_hor_separator.counter?=?0

       cast(separator[draw_hor_separator.counter])

       draw_hor_separator.counter?+=?1def?draw_row(row):

       cast(''.join('|{:?^5}?'.format(num)?if?num?>?0?else?'|?'?for?num?in?row)?+?'|')

       screen.clear()

       cast('SCORE:?'?+?str(self.score))if?0?!=?self.highscore:

       cast('HGHSCORE:?'?+?str(self.highscore))for?row?in?self.field:

       draw_hor_separator()

       draw_row(row)

       draw_hor_separator()if?self.is_win():

       cast(win_string)else:if?self.is_gameover():

       cast(gameover_string)else:

       cast(help_string1)

       cast(help_string2)def?spawn(self):

       new_element?=?4?if?randrange(100)?>?89?else?2

       (i,j)?=?choice([(i,j)?for?i?in?range(self.width)?for?j?in?range(self.height)?if?self.field[i][j]?==?0])self.field[i][j]?=?new_elementdef?move_is_possible(self,?direction):def?row_is_left_movable(row):?

       def?change(i):?#?true?if?there'll?be?change?in?i-th?tileif?row[i]?==?0?and?row[i?+?1]?!=?0:?#?Movereturn?Trueif?row[i]?!=?0?and?row[i?+?1]?==?row[i]:?#?Mergereturn?Truereturn?Falsereturn?any(change(i)?for?i?in?range(len(row)?-?1))

       check?=?{}

       check['Left']?=?lambda?field:?\

       any(row_is_left_movable(row)?for?row?in?field)

       check['Right']?=?lambda?field:?\

check['Left'](invert(field))

       check['Up']=?lambda?field:?\

       check['Left'](transpose(field))

       check['Down']?=?lambda?field:?\

       check['Right'](transpose(field))if?direction?in?check:return?check[direction](self.field)else:return?Falsedef?main(stdscr):def?init():#重置游戏棋盘

       game_field.reset()return?'Game'def?not_game(state):#画出?GameOver?或者?Win?的界面

       game_field.draw(stdscr)#读取用户输入得到action，判断是重启游戏还是结束游戏

       action?=?get_user_action(stdscr)

       responses?=?defaultdict(lambda:?state)?#默认是当前状态，没有行为就会一直在当前界面循环

       responses['Restart'],?responses['Exit']?=?'Init',?'Exit'?#对应不同的行为转换到不同的状态return?responses[action]def?game():#画出当前棋盘状态

       game_field.draw(stdscr)#读取用户输入得到action

       action?=?get_user_action(stdscr)if?action?==?'Restart':return?'Init'if?action?==?'Exit':return?'Exit'if?game_field.move(action):?#?move?successfulif?game_field.is_win():return?'Win'if?game_field.is_gameover():return?'Gameover'return?'Game'

       state_actions?=?{'Init':?init,'Win':?lambda:?not_game('Win'),'Gameover':?lambda:?not_game('Gameover'),'Game':?game

       }

       curses.use_default_colors()

       game_field?=?GameField(win=32)

       state?=?'Init'#状态机开始循环while?state?!=?'Exit':

       state?=?state_actions[state]()

       curses.wrapper(main)

       #五子棋import?appuifw,e32,key_codes

       from?graphics?import?*def?cn(x):return?x.decode('utf-8')

       def?quit():?_quit=1

       global?running

       running=1

       def?redraw(rect):?canvas.blit(img)def?default():

global?con,color,font

con={"l":15,"x":15,"y":33,"r":13,"n":15}

color={"bg":0x7777bb,"fg":0x333333,"p1":0x000000,"p2":0xffffff,"w":0xff0000}

font=u"Sans?MT?936_S60"def?initial():

global?img,canvas,con,color,cur_x,cur_y,turn,pos1,pos2,pos

appuifw.app.screen='full'

appuifw.app.body=canvas=appuifw.Canvas()

img=Image.new((240,320))

img.clear(color["bg"])

cur_x=7

cur_y=7

turn=1

pos1=[]

pos2=[]

pos=[]

for?i?in?range(con["n"]*con["n"]):

pos.append(0)def?paint_back():

global?img,color,font

#img.text((90,25),cn('欢乐五子棋'),color["fg"],font)

for?i?in?range(con["x"],con["x"]+con["l"]*con["n"]-1,con["l"]):

img.line((i,con["y"],i,con["y"]+con["l"]*(con["n"]-1)),color["fg"])

for?i?in?range(con["y"],con["y"]+con["l"]*con["n"]-1,con["l"]):

img.line((con["x"],i,con["x"]+con["l"]*(con["n"]-1),i),color["fg"])

img.text((40,270),cn('玩家1'),color["p1"],font)

img.text((160,270),cn('玩家2'),color["p2"],font)

img.point((90,263),color["p1"],width=con["r"],fill=color["p1"])

img.point((144,263),color["p2"],width=con["r"],fill=color["p2"])

       def?paint_cur(x,y,sh):

global?img,con,color,pos1,pos2,running

if?running<>1:return

ax=con["x"]+con["l"]*x

ay=con["y"]+con["l"]*y

b=con["l"]/2

if?sh<>0:

c=color["p"+str(sh)]

if?rp((x,y))<>0:

       c=color["w"]

if?sh==0:

c=color["bg"]

img.line((ax-b,ay-2,ax-b,ay-b,ax-2,ay-b),c)

img.line((ax-b,ay+2,ax-b,ay+b,ax-2,ay+b),c)

img.line((ax+b,ay-2,ax+b,ay-b,ax+2,ay-b),c)

img.line((ax+b,ay+2,ax+b,ay+b,ax+2,ay+b),c)

redraw(())def?paint_q(x,y,z):

global?img,con,color

ax=con["x"]+con["l"]*x

ay=con["y"]+con["l"]*y

b=con["l"]/2

if?z==0:

c=color["bg"]

else:

c=color["p"+str(z)]

img.point((ax,ay),c,width=con["r"],fill=c)

redraw(())

if?z==0:

img.line((ax-b,ay,ax+b,ay),c)

img.line((ax,ay-b,ax,ay+b),c)

       def?k_up():

global?cur_x,cur_y,con,turn

paint_cur(cur_x,cur_y,0)

cur_y=cur_y-1

if?cur_y==-1:

cur_y=con["n"]-1

paint_cur(cur_x,cur_y,turn)def?k_down():

global?cur_x,cur_y,con,turn

paint_cur(cur_x,cur_y,0)

cur_y=cur_y+1

if?cur_y==con["n"]:

cur_y=0

paint_cur(cur_x,cur_y,turn)def?k_left():

global?cur_x,cur_y,con,turn

paint_cur(cur_x,cur_y,0)

cur_x=cur_x-1

if?cur_x==-1:

cur_x=con["n"]-1

paint_cur(cur_x,cur_y,turn)def?k_right():

global?cur_x,cur_y,con,turn

paint_cur(cur_x,cur_y,0)

cur_x=cur_x+1

if?cur_x==con["n"]:

cur_x=0

paint_cur(cur_x,cur_y,turn)def?rp(x):

global?con,pos

if?(x[0]<0?or?x[0]>=con["n"]?or?x[1]<0?or?x[1]>=con["n"]):return?0

#print?x,pos[x[0]*con["n"]+x[1]]

return?pos[x[0]*con["n"]+x[1]]def?wp(x,y):

global?con,pos

pos[x[0]*con["n"]+x[1]]=y

       def?win():

for?i?in?pos1:

k=0

for?j?in?range(0,6):

       if?rp((i[0]+j,i[1]))==1:

       k=k+1

       else:

       break

if?k>=5:

       return?1

k=0

for?j?in?range(0,6):

       if?rp((i[0],i[1]+j))==1:

       k=k+1

       else:

       break

if?k>=5:

       return?1

k=0

for?j?in?range(0,6):

       if?rp((i[0]+j,i[1]+j))==1:

       k=k+1

       else:

       break

if?k>=5:

       return?1

k=0

for?j?in?range(0,6):

       if?rp((i[0]+j,i[1]-j))==1:

       k=k+1

       else:

       break

if?k>=5:

       return?1?for?i?in?pos2:

k=0

for?j?in?range(0,6):

       if?rp((i[0]+j,i[1]))==2:

       k=k+1

       else:

       break

if?k>=5:

       return?2

k=0

for?j?in?range(0,6):

       if?rp((i[0],i[1]+j))==2:

       k=k+1

       else:

       break

if?k>=5:

       return?2

k=0

for?j?in?range(0,6):

       if?rp((i[0]+j,i[1]+j))==2:

       k=k+1

       else:

       break

if?k>=5:

       return?2

k=0

for?j?in?range(0,6):

       if?rp((i[0]+j,i[1]-j))==2:

       k=k+1

       else:

       break

if?k>=5:

       return?2

return?0

       def?k_enter():

global?cur_x,cur_y,turn,pos1,pos2,con,color,font,running

if?running<>1:return

if?rp((cur_x,cur_y))==0:

if?turn==1:

       pos1.append((cur_x,cur_y))

       img.rectangle((35,255,100,272),color["bg"])

       img.rectangle((135,255,200,272),color["p2"])

if?turn==2:

       pos2.append((cur_x,cur_y))

       img.rectangle((35,255,100,272),color["p1"])

       img.rectangle((135,255,200,272),color["bg"])

paint_q(cur_x,cur_y,turn)

wp((cur_x,cur_y),turn)

if?win()<>0:

       #img.text((80,300),cn('玩家')+str(turn)+cn("获胜！"),color["fg"],font)

       img.rectangle((35,255,100,272),color["bg"])

       img.rectangle((135,255,200,272),color["bg"])

       paint_cur(cur_x,cur_y,0)

       running=2

turn=3-turn

paint_cur(cur_x,cur_y,turn)def?bindkey():

canvas.bind(key_codes.EKeyUpArrow,?k_up)

canvas.bind(key_codes.EKeyDownArrow,k_down)

canvas.bind(key_codes.EKeyLeftArrow,?k_left)

canvas.bind(key_codes.EKeyRightArrow,k_right)

canvas.bind(key_codes.EKeySelect,k_enter)default()

       initial()

       paint_back()

       paint_cur(cur_x,cur_y,1)

       img.rectangle((35,255,100,272),color["p1"])

       bindkey()redraw(())

       appuifw.app.exit_key_handler?=?quit()

       _quit=0

       while?(1-_quit):

e32.ao_sleep(0.2)

redraw(())

       好了，关于“奥运五环python代码参考”的话题就到这里了。希望大家通过我的介绍对“奥运五环python代码参考”有更全面、深入的认识，并且能够在今后的实践中更好地运用所学知识。