python終端一直在循環

⑴ python循環判定不成立了還在一直循環，將不一樣的值作參數輸入函數後卻還是原來的值

python 中，函數內部修改的形參，並不會改變函數外部實參的值。
以題目中例子為例，首次滿足xn==xn2和yn==yn2時，自然不會執行while循環內的huisu函數，於是退出huisu（定義這一層huisu為A），也就是退出到該層嵌套函數，此時，到達一個外層huisu（定義這一層huisu為B），此時在while循環中，這個時候，xn2是85，yn2就是447。
說白了，就是A中的yn2雖然為448，但B中的yn2始終是447，再外一層的huisu兩個數字就分別是85和446，以此類推。
於是乎，此時，程序會一直在B中執行while循環，不斷輸出同樣的數字，永遠不會退出。

⑵ python一個腳本循環兩次

我的python腳本中有一個問題，for循環有時會重復2次。就像它應該每個字母寫一次，有時（我看到它通常在一個「」之前）它會寫兩次。（很多變數都是用法語寫的，但這並不重要）代碼用於在游戲Raft中在鋼琴上播放歌曲（頂部的數字系列），因此我必須將每個數字分配給鍵盤的一個鍵。你可以在你的電腦上使用代碼，因為按下的鍵是在終端上列印的（注）。我的問題是它不能正確播放，有時會重復同一個鍵。

⑶ python-Socket服務端無限循環接受客戶端，但客戶端一直處於接受服務端信息狀態，無實際信息返回

第一個循環錯了。把第二個循環放在第一個循環裡面。accept完了就收發數據，循環收發。收發完了，關閉了，就回到accept的等待狀態 。

按你現在的邏輯是，accept完成後就一直等待，直到第二次accept

慢慢試驗。建議你accept完成後建立一個線程，單獨進行收發。

⑷ 用python ,怎麼實現無限循環(非死循環)

用多線程並行處理while，需要 print x的話，用列隊獲取。

考慮多線程，開一個線程來無限累加。

import threading##多線程
def a:
while True:
print("hello")
def b:
print("xxxx")

threads=[]

擴展資料：

Python 是一門有條理的和強大的面向對象的程序設計語言，類似於Perl, Ruby, Scheme, Java。自從20世紀90年代初Python語言誕生至今，它已被逐漸廣泛應用於系統管理任務的處理和Web編程。Python在設計上堅持了清晰劃一的風格，這使得Python成為一門易讀、易維護，並且被大量用戶所歡迎的、用途廣泛的語言。

⑸ Python 寫代碼的時候如何防止無限循環卡死，因為是初學者，不小心就無限循環了

一般可以這樣，使用一個變數進行計數，每循環一次加1，當值大於某個值（比如1000）就跳出循環。

⑹ 求助幫忙看一下用python實現快速排序的代碼為什麼一直無限循環了應該怎麼修改呢

非常簡單，就把第一個if left > right 改成 left >= right就可以了。。
當left = right的時候也應該是退出的條件，你沒有加上所以就陷入了while != j這個循環裡面了。。
在這個裡面 left = right =j,而i=left+1=j+1，所以i>j,而你的判斷條件只有i<j的，所以兩個while和一個if都不滿足就一直死循環了。。

⑺ Python中的10條冷門知識

下面時Python中一些不常見的冷門知識，感興趣的小夥伴不妨來學習一下。
1、省略號也是對象
… 這是省略號，在Python中，一切皆對象。它也不例外。在 Python 中，它叫做 Ellipsis 。在 Python 3 中你可以直接寫…來得到這玩意。
>>> ...
Ellipsis
>>> type(...)
<class 'ellipsis'>
而在 Python2 中沒有…這個語法，只能直接寫Ellipsis來獲取。
>>> Ellipsis
Ellipsis
>>> type(Ellipsis)
<type 'ellipsis'>
它轉為布爾值時為真
>>> bool(...)
True
最後，這東西是一個單例。
>>> id(...)
4362672336
>>> id(...)
4362672336
這東西有啥用呢？據說它是Numpy的語法糖，不玩 Numpy 的人，可以說是沒啥用的。
在網上只看到這個 用 … 代替 pass ，稍微有點用，但又不是必須使用的。
try:
1/0
except ZeroDivisionError:
...
2、增量賦值的性能更好
諸如 += 和 *= 這些運算符，叫做 增量賦值運算符。這里使用用 += 舉例，以下兩種寫法，在效果上是等價的。
# 第一種
a = 1 ; a += 1
# 第二種
a = 1; a = a + 1
+= 其背後使用的魔法方法是 iadd，如果沒有實現這個方法則會退而求其次，使用 add 。
這兩種寫法有什麼區別呢？
用列表舉例 a += b，使用 add 的話就像是使用了a.extend(b),如果使用 add 的話，則是 a = a+b,前者是直接在原列表上進行擴展，而後者是先從原列表中取出值，在一個新的列表中進行擴展，然後再將新的列表對象返回給變數，顯然後者的消耗要大些。
所以在能使用增量賦值的時候盡量使用它。
3、and 和or 的取值順序
and 和 or 是我們再熟悉不過的兩個邏輯運算符。而我們通常只用它來做判斷，很少用它來取值。
如果一個or表達式中所有值都為真，Python會選擇第一個值，而and表達式則會選擇第二個。
>>>(2 or 3) * (5 and 7)
14 # 2*7
4、修改解釋器提示符
>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>>
>>> sys.ps2 = '---------------- '
>>> sys.ps1 = 'Python編程時光>>>'
Python編程時光>>>for i in range(2):
---------------- print (i)
----------------
5、默認參數最好不為可變對象
函數的參數分三種
可變參數
默認參數
關鍵字參數
今天要說的是，傳遞默認參數時，新手很容易踩雷的一個坑。
先來看一個示例：
def func(item, item_list=[]):
item_list.append(item)
print(item_list)
func('iphone')
func('xiaomi', item_list=['oppo','vivo'])
func('huawei')
在這里，你可以暫停一下，思考一下會輸出什麼？
思考過後，你的答案是否和下面的一致呢
['iphone']
['oppo', 'vivo', 'xiaomi']
['iphone', 'huawei']
如果是，那你可以跳過這部分內容，如果不是，請接著往下看，這里來分析一下。
Python 中的 def 語句在每次執行的時候都初始化一個函數對象，這個函數對象就是我們要調用的函數，可以把它當成一個一般的對象，只不過這個對象擁有一個可執行的方法和部分屬性。
對於參數中提供了初始值的參數，由於 Python 中的函數參數傳遞的是對象，也可以認為是傳地址，在第一次初始化 def 的時候，會先生成這個可變對象的內存地址，然後將這個默認參數 item_list 會與這個內存地址綁定。在後面的函數調用中，如果調用方指定了新的默認值，就會將原來的默認值覆蓋。如果調用方沒有指定新的默認值，那就會使用原來的默認值。
在這里插入圖片描述
6、訪問類中的私有方法
大家都知道，類中可供直接調用的方法，只有公有方法（protected類型的方法也可以，但是不建議）。也就是說，類的私有方法是無法直接調用的。
這里先看一下例子
class Kls():
def public(self):
print('Hello public world!')
def __private(self):
print('Hello private world!')
def call_private(self):
self.__private()
ins = Kls()
# 調用公有方法，沒問題
ins.public()
# 直接調用私有方法，不行
ins.__private()
# 但你可以通過內部公有方法，進行代理
ins.call_private()
既然都是方法，那我們真的沒有方法可以直接調用嗎？
當然有啦，只是建議你千萬不要這樣弄，這里只是普及，讓你了解一下。
# 調用私有方法，以下兩種等價
ins._Kls__private()
ins.call_private()
7、時有時無的切片異常
這是個簡單例子
my_list = [1, 2, 3, 4, 5]
print(my_list[5])
Traceback (most recent call last):
File "F:/Python Script/test.py", line 2, in <mole>
print(my_list[5])
IndexError: list index out of range
來看看，如下這種寫法就不會報索引異常，執行my_list[5:]，會返回一個新list：[]。
my_list = [1, 2, 3]
print(my_list[5:])
8、for 死循環
for 循環可以說是 基礎得不能再基礎的知識點了。但是如果讓你用 for 寫一個死循環，你會寫嗎？（問題來自群友 陳**）
這是個開放性的問題，在往下看之前，建議你先嘗試自己思考，你會如何解答。
好了，如果你還沒有思路，那就來看一下 一個海外 MIT 群友的回答:
for i in iter(int, 1):pass
是不是懵逼了。iter 還有這種用法？這為啥是個死循環？
這真的是個冷知識，關於這個知識點，你如果看中文網站，可能找不到相關資料。
還好你可以通過 IDE 看py源碼里的注釋內容，介紹了很詳細的使用方法。
原來iter有兩種使用方法，通常我們的認知是第一種，將一個列表轉化為一個迭代器。
而第二種方法，他接收一個 callable對象，和一個sentinel 參數。第一個對象會一直運行，直到它返回 sentinel 值才結束。
在這里插入圖片描述
那int 呢，這又是一個知識點，int 是一個內建方法。通過看注釋，可以看出它是有默認值0的。你可以在終端上輸入 int() 看看是不是返回0。
在這里插入圖片描述
由於int() 永遠返回0，永遠返回不了1，所以這個 for 循環會沒有終點。一直運行下去。
9、奇怪的字元串
字元串類型作為 Python 中最常用的數據類型之一，Python解釋器為了提高字元串使用的效率和使用性能，做了很多優化。
例如：Python 解釋器中使用了 intern（字元串駐留）的技術來提高字元串效率。
什麼是 intern 機制？就是同樣的字元串對象僅僅會保存一份，放在一個字元串儲蓄池中，是共用的，當然，肯定不能改變，這也決定了字元串必須是不可變對象。
示例一
# Python2.7
>>> a = "Hello_Python"
>>> id(a)
32045616
>>> id("Hello" + "_" + "Python")
32045616
# Python3.7
>>> a = "Hello_Python"
>>> id(a)
38764272
>>> id("Hello" + "_" + "Python")
32045616
示例二
>>> a = "MING"
>>> b = "MING"
>>> a is b
True
# Python2.7
>>> a, b = "MING!", "MING!"
>>> a is b
True
# Python3.7
>>> a, b = "MING!", "MING!"
>>> a is b
False
示例三
# Python2.7
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
False
# Python3.7
>>> 'a' * 20 is 'aaaaaaaaaaaaaaaaaaaa'
True
>>> 'a' * 21 is 'aaaaaaaaaaaaaaaaaaaaa'
True
示例四
>>> s1="hello"
>>> s2="hello"
>>> s1 is s2
True
# 如果有空格，默認不啟用intern機制
>>> s1="hell o"
>>> s2="hell o"
>>> s1 is s2
False
# 如果一個字元串長度超過20個字元，不啟動intern機制
>>> s1 = "a" * 20
>>> s2 = "a" * 20
>>> s1 is s2
True
>>> s1 = "a" * 21
>>> s2 = "a" * 21
>>> s1 is s2
False
>>> s1 = "ab" * 10
>>> s2 = "ab" * 10
>>> s1 is s2
True
>>> s1 = "ab" * 11
>>> s2 = "ab" * 11
>>> s1 is s2
False
10、兩次return
我們都知道，try…finally… 語句的用法，不管 try 裡面是正常執行還是報異常，最終都能保證finally能夠執行。
同時，我們又知道，一個函數里只要遇到 return 函數就會立馬結束。
基於以上這兩點，我們來看看這個例子，到底運行過程是怎麼樣的？
>>> def func():
... try:
... return 'try'
... finally:
... return 'finally'
...
>>> func()
'finally'
驚奇的發現，在try里的return居然不起作用。
原因是，在try…finally…語句中，try中的return會被直接忽視，因為要保證finally能夠執行。