“Python基础”的版本间的差异

来自linux中国网wiki
跳到导航 跳到搜索
 
（未显示同一用户的95个中间版本）
第1行： 第1行：
 +
==2024==
 +
https://liaoxuefeng.com/books/python/function/recursive-function/index.html
  
 +
https://github.com/qiwsir/itdiffer/blob/main/self-learning.md
 +
 +
recursive暂时跳过
  
 
[https://www.runoob.com/python3/python3-dictionary.html Python3 字典]
 
[https://www.runoob.com/python3/python3-dictionary.html Python3 字典]
 +
 +
[https://www.ituring.com.cn/book/2118 Python基础教程（第3版）]
 +
 +
=== project 2024===
 +
 +
https://www.ituring.com.cn/book/2118
 +
 +
github/python/project/chapter25CGI/2024
 +
 +
=== Python format 格式化函数===
 +
<pre>
 +
一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
 +
 +
基本语法是通过 {} 和 : 来代替以前的 % 。
 +
 +
"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
 +
'hello world'
 +
 +
eg 2
 +
print("""Content-type: text/html 
 +
 +
<html>
 +
<head>
 +
  <title>Simple Edit</title>
 +
</head>
 +
<body>
 +
  <form method="post" action="simple_edit.cgi" method="POST">
 +
      <textarea name="text" rows="20" cols="20">{}</textarea> <br />
 +
      <input type="submit" >
 +
  </form>
 +
    </body>
 +
</html>
 +
""".format(text))
 +
 +
</pre>
 +
 +
https://www.runoob.com/python/att-string-format.html
 +
 +
[https://blog.csdn.net/yueguang8/article/details/136679538 python之格式化输出format()函数使用总结]
 +
=== abspath===
 +
<pre>
 +
 +
In [1]: import os
 +
 +
In [2]: os.path.abspath("w.py")
 +
Out[2]: '/home/evan/data/python/cgi/w.py'
 +
 +
In [3]: ls
 +
1.cgi*  edit.cgi  index.html  powers.py  save.cgi  simple_edit.cgi*  simple_edit.dat  w.py*
 +
 +
</pre>
 +
https://stackoverflow.com/questions/51520/how-to-get-an-absolute-file-path-in-python
 +
 +
=== threading===
 +
<pre>
 +
import threading
 +
import requests
 +
 +
# 目标URL列表
 +
urls = [
 +
    "http://www.google.com",
 +
    "http://www.bing.com",
 +
    "http://www.stackoverflow.com",
 +
    # 添加更多URL
 +
]
 +
 +
# 检查URL可达性的函数
 +
def check_url(url):
 +
    try:
 +
        response = requests.get(url, timeout=5)
 +
        if response.status_code == 200:
 +
            print(f"{url} is up and running.")
 +
        else:
 +
            print(f"{url} returned status code {response.status_code}.")
 +
    except requests.RequestException as e:
 +
        print(f"{url} is down. Error: {e}")
 +
 +
# 创建线程列表
 +
threads = []
 +
 +
# 为每个URL创建并启动一个线程
 +
for url in urls:
 +
    thread = threading.Thread(target=check_url, args=(url,))
 +
    threads.append(thread)
 +
    thread.start()
 +
 +
# 等待所有线程完成
 +
for thread in threads:
 +
    thread.join()
 +
 +
print("All URLs have been checked.")
 +
</pre>
 +
=== json===
 +
[https://www.bilibili.com/video/BV11q4y1s74P?spm_id_from=333.788.videopod.episodes&vd_source=e3e41ea2b1d70e0e3a6a0372ee88d714&p=9 json b站]
 +
 +
<pre>
 +
 +
In [1]: import json
 +
 +
In [2]: adict = {'user': 'evan','age':20}
 +
 +
In [3]: json.dumps(adict)
 +
Out[3]: '{"user": "evan", "age": 20}'
 +
 +
In [4]: data=json.dumps(adict)
 +
 +
In [5]: data
 +
Out[5]: '{"user": "evan", "age": 20}'
 +
 +
In [6]: type(data)
 +
Out[6]: str
 +
发送 (编码)
 +
***
 +
接收后 转为 py的dict
 +
In [7]: json.loads(data)
 +
Out[7]: {'user': 'evan', 'age': 20}
 +
 +
In [8]: jdata=json.loads(data)
 +
 +
In [9]: type(jdata)
 +
Out[9]: dict
 +
 +
 +
 +
</pre>
 +
 +
==== 天气预报====
 +
<pre>
 +
https://e.weather.com.cn/mweather/101280101.shtml
 +
 +
广州 01010704
 +
      0101070401 白云
 +
      0101070402 从化
 +
      0101070403 海珠
 +
      0101070404 花都
 +
      0101070405 黄埔
 +
      0101070406 荔湾
 +
      0101070407 萝岗
 +
      0101070408 南沙
 +
      0101070409 番禺
 +
      0101070410 天河
 +
      0101070411 越秀
 +
      0101070412 增城
 +
</pre>
 +
 +
== python for devops==
 +
=== chapter 3 ===
 +
<pre>
 +
In [1]: import s
 +
hello evan
 +
 +
In [2]: cat s.py
 +
def say_it():
 +
    greeting = 'hello'
 +
    target = 'evan'
 +
    message = f'{greeting} {target}'
 +
    print(message)
 +
 +
say_it()
 +
 +
 +
➜  tmp python argv.py  --a-flag some-value 13
 +
the 1 argument: 'argv.py'
 +
the 2 argument: '--a-flag'
 +
the 3 argument: 'some-value'
 +
the 4 argument: '13'
 +
➜  tmp cat argv.py
 +
import  sys
 +
if __name__ == '__main__':
 +
    print(f"the 1 argument: '{sys.argv[0]}'")
 +
    print(f"the 2 argument: '{sys.argv[1]}'")
 +
    print(f"the 3 argument: '{sys.argv[2]}'")
 +
    print(f"the 4 argument: '{sys.argv[3]}'")
 +
➜  tmp
 +
 +
</pre>
 +
 
== Python项目读取配置方式 ==
 
== Python项目读取配置方式 ==
 
  常见的是 import configparser
 
  常见的是 import configparser
 
[https://www.cnblogs.com/zhangyafei/p/10265072.html  Python项目读取配置的几种方式 ]
 
[https://www.cnblogs.com/zhangyafei/p/10265072.html  Python项目读取配置的几种方式 ]
−
 
  
 
==python中字典的循环遍历的两种方式==
 
==python中字典的循环遍历的两种方式==
第54行： 第235行：
  
 
===python读取文件===
 
===python读取文件===
 +
 +
[https://www.codenong.com/3277503/ python:如何将文件逐行读取到列表中?]
  
 
[https://blog.csdn.net/huguangshanse00/article/details/14639871  python 读取文本文件内容转化为python的list]
 
[https://blog.csdn.net/huguangshanse00/article/details/14639871  python 读取文本文件内容转化为python的list]
  
 
[https://blog.csdn.net/whatday/article/details/108923273  python 四种逐行读取文件内容的方法]
 
[https://blog.csdn.net/whatday/article/details/108923273  python 四种逐行读取文件内容的方法]
 +
==Python 函数返回值 ==
 +
[https://www.cnblogs.com/i-honey/p/7679897.html Python 函数返回值]
 +
 +
== py linux系统管理==
 +
<pre>
 +
In [6]: [item for item in os.listdir(os.path.expanduser('/tmp')) if os.path.isdir(item)]
 +
Out[6]: []
 +
 +
In [7]: [item for item in os.listdir(os.path.expanduser('/tmp')) if os.path.isdir(item)]
 +
Out[7]: []
 +
 +
打印最常用10条命令
 +
import os
 +
from collections import Counter
 +
 +
c = Counter()
 +
 +
# 读取bash历史记录文件并统计命令频率
 +
with open(os.path.expanduser('~/.bash_history')) as f:
 +
    for line in f:
 +
# whith open(os.path.expanduser(' ~/.bash_history')) as f:
 +
 +
        cmd = line.strip().split()
 +
        if cmd:
 +
            c[cmd[0]] += 1
 +
            print(c.most_common(10))
 +
 +
 +
 +
# with open('example.txt', 'r') as file:
 +
#    content = file.read()
 +
#    print(content)
 +
 +
# [('ls', 352), ('cd', 309), ('bash', 161), ('cat', 114), ('vim', 78), ('sudo', 54), ('vi', 46), ('geany', 33), ('ssh', 31), ('python3', 27)]
 +
# [('ls', 352), ('cd', 309), ('bash', 161), ('cat', 114), ('vim', 78), ('sudo', 54), ('vi', 46), ('geany', 33), ('ssh', 31), ('python3', 27)]
 +
# [('ls', 352), ('cd', 309), ('bash', 162), ('cat', 114), ('vim', 78), ('sudo', 54), ('vi', 46), ('geany', 33), ('ssh', 31), ('python3', 27)]
 +
 +
def  execute_cmd(cmd):
 +
    p = subprocess.Popen(cmd,
 +
                        shell=True,
 +
                        stdin=subprocess.PIPE,
 +
                        stdout=subprocess.PIPE,
 +
                        stderr=subprocess.PIPE)
 +
    stdout,stderr = p.communicate()
 +
    if p.returncode != 0:
 +
        return p.returncode, stderr
 +
    return p.returncode, stdout
 +
 +
 +
    函数定义
 +
        def execute_cmd(cmd):定义了一个名为execute_cmd的函数，它接受一个参数cmd，这个参数应该是一个表示命令的字符串或者是一个可以被当作命令执行的对象（在shell=True的情况下）。
 +
    subprocess.Popen调用
 +
        p = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 +
            这行代码使用subprocess模块创建了一个新的子进程来执行命令。
 +
            shell=True表示命令将在一个 shell 环境中执行。这使得可以执行一些复杂的 shell 命令，比如包含管道、重定向等操作的命令。
 +
            stdin=subprocess.PIPE、stdout=subprocess.PIPE和stderr=subprocess.PIPE分别表示将子进程的标准输入、标准输出和标准错误流连接到管道，以便可以获取和处理这些输出和错误信息。
 +
    p.communicate调用
 +
        stdout,stderr = p.communicate()
 +
            这个方法用于与子进程进行通信，它会等待子进程完成，并返回一个包含标准输出和标准错误的元组。
 +
            在这里，stdout将获取子进程的标准输出内容，stderr将获取子进程的标准错误内容。
 +
    返回值处理
 +
        if p.returncode!= 0:
 +
            这里检查子进程的返回码。如果返回码不为 0，说明命令执行过程中出现了错误。
 +
            在这种情况下，return p.returncode, stderr会返回子进程的返回码和标准错误信息。
 +
        return p.returncode, stdout
 +
            如果子进程的返回码为 0，说明命令执行成功，此时会返回子进程的返回码和标准输出信息。
 +
 +
 +
这段代码的主要功能是执行一个命令，并根据命令执行的结果返回相应的信息。如果命令执行成功，返回命令的返回码和标准输出；如果命令执行失败，返回命令的返回码和标准错误。
 +
 +
</pre>
 +
 +
 +
===depoly_mongodb.py ===
 +
<pre>
 +
#!/usr/bin/env python
 +
#-*- coding:utf-8 -*-
 +
from  __future__ import print_function
 +
import os
 +
import shutil
 +
import subprocess
 +
import tarfile
 +
 +
def  execute_cmd(cmd):
 +
    p = subprocess.Popen(cmd,
 +
                        shell=True,
 +
                        stdin=subprocess.PIPE,
 +
                        stdout=subprocess.PIPE,
 +
                        stderr=subprocess.PIPE)
 +
    stdout,stderr = p.communicate()
 +
    if p.returncode != 0:
 +
        return p.returncode, stderr
 +
    return p.returncode, stdout
 +
 +
def unpackage_mongo(package, package_dir):
 +
    unpackage_dir = os.path.splitext(package)[0]
 +
    if os.path.exists(package_dir):
 +
        shutil.rmtree(package_dir)
 +
 +
    if os.path.exists(papckage_dir):
 +
        shutil.rmtree(package_dir)
 +
 +
    t = tarfile.open(package,'r:gz')
 +
    t.extractall('.')
 +
 +
    shutil.move(unpackage_dir, package_dir)
 +
 +
def create_datadir(data_dir):
 +
    if os.path.exists(data_dir):
 +
        shutil.rmtree(data_dir)
 +
    os.makedirs(data_dir)
 +
 +
def forma_mongod_command(package_dir, data_dir, logfile):
 +
    mongod = os.path.join(package_dir, 'mongod')
 +
    mongod_format =  """{0} --fork --dbpath {1} --logpath {2}"""
 +
    return mongod_format.format(mongod, data_dir, logfile)
 +
 +
def start_mongo(cmd):
 +
    returncode, out = execute_cmd(cmd)
 +
    if returncode != 0:
 +
        raise SystemExit('execute {0} error :{1}'.format(cmd, out))
 +
    else:
 +
        print('execute {0} success'.format(cmd))
 +
 +
 +
def main():
 +
    package = 'mongodb-linux-x86_64-debian11-5.0.29.tgz'
 +
    #package = 'https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.2.10.tgz'
 +
    curl_dir = os.path.abspath('.')
 +
    package_dir  =  os.path.join(curl_dir, 'mongo')
 +
    data_dir = os.path.join(cur_dir, 'mongodata')
 +
    logfile = os.path.join(data_dir,'mongod.log')
 +
 +
    if not os.paht.exists(package):
 +
        raise SystemExit(" {0} not found ", format(package))
 +
   
 +
    unpackage_mongo(package, package_dir)
 +
 +
if __name__ ==  '__main__':
 +
    main()
 +
 +
 +
# 代码解读  unpackage_dir = os.path.splitext(package)[0]
 +
# 以下是对这段代码的解读：
 +
 +
#    os.path.splitext(package)
 +
#        这是 Python 中os.path模块提供的一个函数。它的作用是将文件名（这里是package变量所代表的文件名）拆分成文件名和扩展名两部分。
 +
#        例如，如果package是"example.txt"，那么os.path.splitext(package)将返回("example", ".txt")。
 +
#    unpackage_dir = os.path.splitext(package)[0]
 +
#        这里取os.path.splitext(package)返回结果的第一个元素。
 +
#        继续上面的例子，如果package是"example.txt"，那么unpackage_dir将被赋值为"example"。
 +
#        其目的通常是获取文件名中除去扩展名的部分，可能是为了进一步操作，比如创建一个与该文件名（除去扩展名）相关的目录等。
 +
 +
</pre>
 +
=== 文本处理===
 +
<pre>
 +
In [39]: import os
 +
p75
 +
In [40]: [ item for item in os.listdir('.') if item.endswith('.py')]
 +
Out[40]:
 +
['1.py',
 +
'checkprocess.py',
 +
'dump.py',
 +
'judge.py',
 +
'rename.py',
 +
'devresize.py',
 +
 +
 +
# 在不在另外一个str 中用in or not in
 +
In [45]: 'in' in s
 +
Out[45]: True
 +
 +
In [46]: "".join(['a','b','c'])
 +
Out[46]: 'abc'
 +
 +
In [47]: str.join?
 +
Signature: str.join(self, iterable, /)
 +
Docstring:
 +
Concatenate any number of strings.
 +
 +
The string whose method is called is inserted in between each given string.
 +
The result is returned as a new string.
 +
 +
Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 +
Type:      method_descriptor
 +
 +
 +
In [54]: from collections import Counter
 +
 +
In [55]: c = Counter('abcba')
 +
 +
In [56]: c
 +
Out[56]: Counter({'a': 2, 'b': 2, 'c': 1})
 +
 +
In [57]: c['a'] += 1
 +
 +
In [58]: c
 +
Out[58]: Counter({'a': 3, 'b': 2, 'c': 1})
 +
 +
In [59]: c.most_common(2)
 +
Out[59]: [('a', 3), ('b', 2)]
 +
 +
 +
字符串格式化
 +
In [5]: "{} is better than {}. {} is better than {}.". format('Beaufiful', 'ugly', 'explicit', 'implicit')
 +
Out[5]: 'Beaufiful is better than ugly. explicit is better than implicit.'
 +
</pre>
 +
====re====
 +
<pre>
 +
In [6]: import re
 +
 +
In [7]: data = "what is the difference between pyuthon 2.7.12 and python 3.6 ?"
 +
 +
In [10]: re.findall('python [0-9]\.[0-9]\.[0-9]',data)
 +
<>:1: SyntaxWarning: invalid escape sequence '\.'
 +
<ipython-input-10-15bd1c311994>:1: SyntaxWarning: invalid escape sequence '\.'
 +
  re.findall('python [0-9]\.[0-9]\.[0-9]',data)
 +
Out[10]: []
 +
 +
In [11]: re.findall('python',data)
 +
Out[11]: ['python']
 +
 +
import re 
 +
 +
def main():
 +
    pattern = "[0-9]+"
 +
    re_obj = re.compile(pattern)
 +
    with open('data.txt') as f:
 +
        for line in f:
 +
            print(re_obj.findall(line))
 +
 +
if __name__ == '__main__':
 +
    main()
 +
 +
 +
#    ➜  tmp py3 re_compile.py
 +
# ['12234']
 +
# ['22222']
 +
# ['3333']
 +
 +
# ➜  tmp cat data.txt
 +
# dafasf12234
 +
# ddd22222
 +
# 3333dddd% 
 +
 +
>>> import re
 +
>>> import re,requests
 +
>>> r = requests.get('https://news.ycombinator.com/')
 +
>>>
 +
>>> re.findall('"(https?://.*?)"',r.content)
 +
 +
</pre>
 +
 +
===== match.group(1)=====
 +
<pre>
 +
 +
    match.group(1)的含义
 +
        在 Python 的re（正则表达式）模块中，当使用re.search()、re.match()或re.finditer()等函数进行正则表达式匹配时，会返回一个匹配对象（通常用match表示）。
 +
        match.group(1)用于获取正则表达式中第一个分组（group）匹配到的内容。
 +
        例如，假设有正则表达式r'(abc)(def)'，当用这个正则表达式对字符串'abcdef'进行匹配时：
 +
            整个正则表达式(abc)(def)会匹配整个'abcdef'字符串。
 +
            match.group(0)会返回整个匹配的字符串，即'abcdef'。
 +
            match.group(1)会返回第一个分组(abc)匹配到的字符串，即'abc'。
 +
            match.group(2)会返回第二个分组(def)匹配到的字符串，即'def'。
 +
        如果正则表达式中的分组没有匹配到任何内容，那么调用match.group(1)（或其他分组索引）可能会引发一个IndexError。
 +
 +
 +
例如，考虑以下代码：
 +
 +
 +
 +
import re
 +
 +
pattern = r'(\d+)\s+(\w+)'
 +
string = '123 abc'
 +
match = re.search(pattern, string)
 +
if match:
 +
    print(match.group(0))  # 输出: 123 abc
 +
    print(match.group(1))  # 输出: 123
 +
    print(match.group(2))  # 输出: abc
 +
 +
</pre>
 +
 +
===chapter 3===
 +
 +
Click
 +
https://click.palletsprojects.com/en/stable/
 +
 +
===chapter 5  ===
 +
==== E5 ====
 +
 +
In [2]: import glob
 +
 +
In [3]: glob.glob('*.py')
 +
Out[3]:
 +
['1.py',
 +
'deploy-mongo.py',
 +
'2.py',
 +
'moni-php.py',
 +
'c.py',
 +
'errmv.py',
 +
'with.py',
 +
'test__file__.py']
 +
 +
os.walk
 +
<pre>
 +
import os
 +
import fnmatch
 +
 +
pys=['*.py','*.pyw']
 +
matches = []
 +
 +
for root, dirnames, filenames in os.walk(os.path.expanduser("/home/evan/data/tmp/py")):
 +
    for extensions in pys:
 +
        for filename in fnmatch.filter(filenames, extensions):
 +
            matches.append(os.path.join(root, filename))
 +
 +
print(matches)
 +
 +
'/home/evan/data/tmp/py/md5.py', '/home/evan/data/tmp/py/pe.py', '/home/evan/data/tmp/py/get10.py', '/home/evan/data/tmp/py/pscp.py', '/home/evan/data/tmp/py/p.py', '/home/evan/data/tmp/py/read_from_fileinput2.py', '/home/evan/data/tmp/py/read_stdin2.py', '/home/evan/data/tmp/py/pp.py', '/home/evan/data/tmp/py/read_from_fileinput.py', '/home/evan/data/tmp/py/default_logging.py']
 +
  
 +
 +
 +
</pre>
 +
 +
shutil
 +
 +
In [4]: shutil.copy('1.txt','2.txt')
 +
Out[4]: '2.txt'
 +
 +
In [5]: shutil.copytree('__pycache__','dd')
 +
Out[5]: 'dd'
 +
 +
===chapter 8===
 +
===== 8.4 DNS=====
 +
<pre>
 +
In [3]: import dns.resolver
 +
 +
In [4]: data=dns.resolver.query('linuxsa.org','A')
 +
<ipython-input-4-f5f420be195e>:1: DeprecationWarning: please use dns.resolver.resolve() instead
 +
  data=dns.resolver.query('linuxsa.org','A')
 +
 +
In [5]: for item in data.response.answer:
 +
  ...:    print(item)
 +
linuxsa.org. 300 IN A 104.21.72.8
 +
linuxsa.org. 300 IN A 172.67.173.102
 +
 +
 +
➜  ~ dig linuxsa.org
 +
 +
; <<>> DiG 9.16.15-Debian <<>> linuxsa.org
 +
;; global options: +cmd
 +
;; Got answer:
 +
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10748
 +
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
 +
 +
;; OPT PSEUDOSECTION:
 +
; EDNS: version: 0, flags:; udp: 4096
 +
;; QUESTION SECTION:
 +
;linuxsa.org. IN A
 +
 +
;; ANSWER SECTION:
 +
linuxsa.org. 274 IN A 172.67.173.102
 +
linuxsa.org. 274 IN A 104.21.72.8
 +
 +
</pre>
 +
 +
===chapter 11  ===
 +
==== 上下文====
 +
<pre>
 +
 +
with open('file1','r') as source, open('file2','w') as target:
 +
    target.write(source.read())
 +
</pre>
 +
 +
====mysql====
 +
<pre>
 +
 +
 +
 +
import os
 +
import pymysql  as db
 +
# if os.getenv('DB','MySQL') == 'MySQL':
 +
#    import MySQLdb as db
 +
# else:
 +
#    import sqlite3 as db
 +
 +
def get_conn(**kwargs):
 +
    if os.getenv('DB', 'MySQL') == 'MySQL':
 +
        return db.connect(host=kwargs.get('host', 'localhost'),
 +
            user=kwargs.get('user'),
 +
            passwd=kwargs.get('passwd'),
 +
            port=kwargs.get('port', 3306),
 +
            db=kwargs.get('db'))
 +
    else:
 +
        return db.connect(database=kwargs.get('db'))
 +
 +
def main():
 +
    conn = get_conn(host='127.0.0.1',
 +
            user='root',
 +
            passwd='evan2240881',
 +
            port=3306,
 +
            db='bbs')
 +
 +
    # get cursor object
 +
    cur = conn.cursor()
 +
 +
    # execute SQL statement
 +
    cur.execute("select * from messages")
 +
    print(cur.fetchall())
 +
 +
    # close resources
 +
    cur.close()
 +
    conn.close()
 +
 +
 +
if __name__ == '__main__':
 +
    main()
 +
 +
 +
#  tmp py3 connect_mysql.py
 +
# ((1, '', '', None, ''), (2, '2', 'evan', None, 'evan'))   
 +
</pre>
 +
 +
==range==
 +
[https://www.runoob.com/python3/python3-func-range.html Python3 range() 函数用法]
 +
 +
== learn==
 +
<pre>
 +
py作为很多开发项目的辅助语言现在来说会更流行一些，不管是github还是其他地方。所以，你能找到的帮助，解决问题的思路也比perl广。
 +
追问
 +
 +
python 自学容易么，可否推荐基本书看看
 +
 +
追答
 +
 +
首先我推荐你从这边开始入门，我以前也是这边看。http://woodpecker.org.cn/abyteofpython_cn/chinese/index.html， 自学容易的。
 +
 +
，不需要急，等大部分了解后，并且使用py写脚本一段时间之后，你会开始需要更多模块的用法，这时候到 https://docs.python.org/2.7/ 这里查。
 +
书的话，我觉得如果你想成为语法大师的话，O'REILLY 的 跟 这两本，
 +
 +
不会的问题，用google搜，特别是Stack Overflow 的站点上搜往往能找到答案。
 +
当觉得已经对py很熟悉之后，可以看别人的py项目。然后用一些好用的框架比如django啥的，那么就合格了。然后模块就是越用越熟悉
 +
</pre>
 +
===Apr 2024 ===
 +
<pre>
 +
tuple
 +
英 [tjʊpəl; ˈtʌpəl] 美 [ˈtjʊpəl; ˈtʌpəl]    n. [计] 元组，重数
 +
 +
 +
</pre>
 +
 +
 +
 +
 +
 +
安装 VS Code Python
 +
 +
[https://www.runoob.com/python3/python-vscode-setup.html Python VScode 配置]
 +
 +
[https://www.runoob.com/python3/fitten-code.html Python AI 编程助手]
 +
 +
====str====
 +
<pre>
 +
In [3]: s = "hello"
 +
 +
In [4]: s[0] = 'H'
 +
---------------------------------------------------------------------------
 +
TypeError                                Traceback (most recent call last)
 +
<ipython-input-4-d6f3b193531a> in <module>
 +
----> 1 s[0] = 'H'
 +
 +
TypeError: 'str' object does not support item assignment
 +
 +
In [5]: s = 'H' + s[1:]
 +
 +
In [6]: s
 +
Out[6]: 'Hello'
 +
 +
In [7]: s = "Hello, world"
 +
 +
In [8]: s[:5]
 +
Out[8]: 'Hello'
 +
 +
In [9]: s[::-1]
 +
Out[9]: 'dlrow ,olleH'
 +
 +
In [10]: ''.join(reversed(s))
 +
Out[10]: 'dlrow ,olleH'
 +
 +
In [11]:
 +
 +
</pre>
 +
====list ====
 +
 +
与Python字符串不一样的是，列表中的元素是可以改变的
 +
<pre>
 +
 +
 +
def reverseWords(input):
 +
    inputWords = input.split()
 +
    inputWords=inputWords[-1::-1]
 +
 +
    output= ' '.join(inputWords)
 +
    return output
 +
 +
if __name__ ==  "__main__":
 +
    input =  'I love evan'
 +
    rw = reverseWords(input)
 +
    print(rw)
 +
 +
'''
 +
 +
evan love I
 +
 +
    # 翻转字符串
 +
    # 假设列表 list = [1,2,3,4], 
 +
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
 +
    # inputWords[-1::-1] 有三个参数
 +
    # 第一个参数 -1 表示最后一个元素
 +
    # 第二个参数为空，表示移动到列表末尾
 +
    # 第三个参数为步长，-1 表示逆向
 +
https://www.runoob.com/python3/python3-data-type.html   
 +
''' 
 +
</pre>
 +
 +
====Tuple（元组）====
 +
 +
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
 +
 +
元组中的元素类型也可以不相同
 +
 +
<pre>
 +
tup2 = (20,) # 一个元素，需要在元素后添加逗号
 +
 +
如果你想创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。
 +
 +
如果不添加逗号，如下所示，它将被解释为一个普通的值而不是元组：
 +
 +
not_a_tuple = (42)
 +
</pre>
 +
 +
修改元组
 +
 +
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
 +
 +
https://www.runoob.com/python3/python3-tuple.html
 +
 +
====Dictionary====
 +
 +
====Python3 条件控制====
 +
 +
 +
=====match...case=====
 +
 +
Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了
 +
<pre>
 +
def http_error(status):
 +
    match status:
 +
        case 400:
 +
            return "bad request"
 +
        case 404:
 +
            return "not Found"
 +
        case 418:
 +
            return "I am a  teapot"
 +
        case _:
 +
            return "something's wrong with the internet"
 +
       
 +
mystatus=400
 +
print(http_error(mystatus))   
 +
 +
# bad request
 +
</pre>
 +
====Python3 循环语句====
 +
<pre>
 +
斐波纳契数列
 +
 +
n=3
 +
a, b = 0,1
 +
for  i in range(n):
 +
    print("斐波纳契数列为%d"%(b))
 +
    a,b = b,a+b
 +
    print("a is %d  b is %d" %(a,b))
 +
'''
 +
其中代码 a, b = b, a+b 的计算方式为先计算右边表达式，然后同时赋值给左边，等价于：
 +
 +
n=b
 +
m=a+b
 +
a=n
 +
b=m
 +
'''
 +
 +
[Running] /usr/bin/python3  "/home/evan/tmp/py/2.py"
 +
斐波纳契数列为1
 +
a is 1  b is 1
 +
斐波纳契数列为1
 +
a is 1  b is 2
 +
斐波纳契数列为2
 +
a is 2  b is 3
 +
</pre>
 +
 +
 +
 +
====Python 推导式====
 +
 +
 +
====Python3 迭代器与生成器 ====
 +
 +
 +
 +
====Python3 函数====
 +
 +
<pre>
 +
 +
 +
 +
 +
 +
def area(width, height):
 +
    return  width * height
 +
 +
def print_welcome(name):
 +
    print("welcome",name)
 +
 +
print_welcome("evan")
 +
w = 4
 +
h = 5 
 +
print("width =", w, "height =", h , "area =", area(w,h))
 +
 +
welcome evan
 +
width = 4 height = 5 area = 20
 +
</pre>
 +
 +
 +
 +
<pre>
 +
x = lambda a : a + 10
 +
print(x(5))
 +
# Output: 15
 +
</pre>
 +
 +
强制位置参数
 +
 +
https://www.runoob.com/python3/python3-function.html
 +
 +
https://zhuanlan.zhihu.com/p/412273465
 +
 +
=====参数传递 =====
 +
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
 +
 +
 +
 +
 +
=====参数=====
 +
以下是调用函数时可使用的正式参数类型：
 +
 +
    必需参数
 +
    关键字参数
 +
    默认参数
 +
    不定长参数
 +
======必需参数  ======
 +
 +
======关键字参数  ======
 +
 +
键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
 +
 +
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值
 +
<pre>
 +
def printinfo( name, age):
 +
    print ("name:", name)
 +
    print ("age:", age )
 +
 +
printinfo( age=40, name="nick")
 +
 +
name: nick
 +
age: 40
 +
</pre>
 +
 +
======默认参数  ======
 +
<pre>
 +
 +
def printinfo( name, age=33):
 +
    print ("name:", name)
 +
    print ("age:", age )
 +
 +
printinfo( age=40, name="nick")
 +
print("88888888888888")
 +
printinfo( name="evan")
 +
 +
name: nick
 +
age: 40
 +
88888888888888
 +
name: evan
 +
age: 33
 +
</pre>
 +
 +
 +
====== 不定长参数======
 +
<pre>
 +
 +
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：
 +
 +
def functionname([formal_args,] *var_args_tuple ):
 +
  "函数_文档字符串"
 +
  function_suite
 +
  return [expression]
 +
 +
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
 +
 +
 +
def printinfo( arg1, *vartuple ):
 +
    print("输出")
 +
    print(arg1)
 +
    print(vartuple)
 +
 +
printinfo( 70,60,50)
 +
 +
输出
 +
70
 +
(60, 50)
 +
 +
还有一种就是参数带两个星号 **基本语法如下：
 +
 +
def functionname([formal_args,] **var_args_dict ):
 +
  "函数_文档字符串"
 +
  function_suite
 +
  return [expression]
 +
 +
加了两个星号 ** 的参数会以字典的形式导入
 +
def printinfo( arg1, **vardict ):
 +
    print("输出")
 +
    print(arg1)
 +
    print(vardict)
 +
 +
printinfo( 70,a=33,b=50)
 +
 +
输出
 +
70
 +
{'a': 33, 'b': 50}
 +
 +
 +
 +
 +
</pre>
 +
====== 匿名函数======
 +
 +
 +
Python 使用 lambda 来创建匿名函数。
 +
 +
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
 +
 +
    lambda 只是一个表达式，函数体比 def 简单很多
 +
 +
<pre>
 +
语法
 +
 +
lambda 函数的语法只包含一个语句，如下：
 +
 +
lambda [arg1 [,arg2,.....argn]]:expression
 +
 +
设置参数 a 加上 10:
 +
实例
 +
x = lambda a : a + 10
 +
print(x(5))
 +
 +
sum = lambda arg1, arg2: arg1 + arg2
 +
 +
print("相加后的value" ,sum( 10, 20))
 +
print("相加后的value" ,sum( 20, 30))
 +
</pre>
 +
=====return 语句=====
 +
<pre>
 +
def sum( arg1, arg2 ):
 +
    total = arg1 + arg2
 +
    print("函数内 : ",total)
 +
    return  total 
 +
 +
total = sum(10,20)
 +
print("函数外",total)
 +
函数内 :  30
 +
函数外 :  30
 +
 +
</pre>
 +
=====强制位置参数=====
 +
<pre>
 +
 +
 +
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
 +
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
 +
 +
def f(a, b, /, c, d, *, e, f):
 +
    print(a, b, c, d, e, f)
 +
 +
以下使用方法是正确的:
 +
 +
f(10, 20, 30, d=40, e=50, f=60)
 +
 +
以下使用方法会发生错误:
 +
 +
f(10, b=20, c=30, d=40, e=50, f=60)  # b 不能使用关键字参数的形式
 +
f(10, 20, 30, 40, 50, f=60)          # e 必须使用关键字参数的形式
 +
 +
</pre>
 +
 +
====Python lambda（匿名函数）====
 +
<pre>
 +
 +
# x=lambda a : a  + 10
 +
# print(x(5))
 +
 +
# sum = lambda arg1, arg2: arg1 + arg2
 +
 +
# print("相加后的value" ,sum( 10, 20))
 +
# print("相加后的value" ,sum( 20, 30))
 +
 +
# def sum( arg1, arg2 ):
 +
#    total = arg1 + arg2
 +
#    print("函数内 : ",total)
 +
#    return  total 
 +
 +
# total = sum(10,20)
 +
# print("函数外",total)
 +
# 函数内 :  30
 +
# 函数外 :  30
 +
 +
# x = lambda a : a + 1
 +
# print(x(2))
 +
 +
# x = lambda a, b , c : a + b + c
 +
# print(x(5,6,2))
 +
 +
# numbers = [1,2,3,4,5]
 +
# squared =  list(map(lambda x: x**2,numbers))
 +
# print(squared)
 +
 +
# # Output: [1, 4, 9, 16, 25]
 +
 +
# numbers=[1,2,3,4,5,6,7,8]
 +
# even_numbrs = list(filter(lambda x: x % 2  ==0, numbers))
 +
# print(even_numbrs)
 +
 +
# # Output: [2, 4, 6, 8]
 +
 +
from  functools  import reeuce 
 +
 +
numbers = [1,2,3,4,5]
 +
product = reduce(lambda x,y: x*y, numbers)
 +
print(product)
 +
 +
# Output: 120
 +
</pre>
 +
 +
 +
====Python 装饰器====
 +
https://www.runoob.com/python3/python-decorators.html
 +
<pre>
 +
语法
 +
 +
def decorator_function(original_function):
 +
    def wrapper(*args, **kwargs):
 +
        # 这里是在调用原始函数前添加的新功能
 +
        before_call_code()
 +
        result = original_function(*args, **kwargs)
 +
 +
        # 这里是在调用原始函数后添加的新功能
 +
        after_call_code()
 +
        return result
 +
    return wrapper
 +
 +
# 使用装饰器
 +
@decorator_function
 +
def target_function(arg1, arg2):
 +
    pass  # 原始函数的实现
 +
 +
 +
使用装饰器
 +
 +
装饰器通过 @ 符号应用在函数定义之前，例如：
 +
 +
@time_logger
 +
def target_function():
 +
    pass
 +
 +
等同于：
 +
 +
def target_function():
 +
    pass
 +
target_function = time_logger(target_function)
 +
 +
这会将 target_function 函数传递给 decorator 装饰器，并将返回的函数重新赋值给 target_function。从而，每次调用 target_function 时，实际上是调用了经过装饰器处理后的函数。
 +
 +
通过装饰器，开发者可以在保持代码整洁的同时，灵活且高效地扩展程序的功能
 +
 +
 +
def repeat(n):
 +
    def decorator(func):
 +
        def wrapper(*args, **kwargs):
 +
            for i in range(n):
 +
                result = func(*args, **kwargs)
 +
            return result
 +
        return wrapper
 +
    return decorator
 +
 +
@repeat(3)
 +
def greet(name):
 +
    print("Hello, " + name)
 +
 +
greet("Evan")
 +
 +
Hello, Evan
 +
Hello, Evan
 +
Hello, Evan
 +
 +
</pre>
 +
 +
==== Python3 数据结构====
 +
====Python3 模块 ====
 +
 +
==== ====
 +
 +
==== ====
 +
 +
==== Python3 File(文件) 方法====
 +
 +
====Python3 面向对象====
 +
<pre>
 +
class MyClass:
 +
    i = 12345
 +
    def f(self):
 +
        return 'hello evan'
 +
   
 +
x = MyClass()
 +
 +
print("Myclass类的属性i 为：",x.i)
 +
print("Myclass类的方法f 的返回值为：",x.f())
 +
 +
Myclass类的属性i 为： 12345
 +
Myclass类的方法f 的返回值为： hello evan
 +
</pre>
 
[[category:devops]]  [[category:python]]
 
[[category:devops]]  [[category:python]]

2024年11月12日 (二) 07:48的最新版本

2024

https://liaoxuefeng.com/books/python/function/recursive-function/index.html

https://github.com/qiwsir/itdiffer/blob/main/self-learning.md

recursive暂时跳过

Python3 字典

Python基础教程（第3版）

project 2024

https://www.ituring.com.cn/book/2118

github/python/project/chapter25CGI/2024

Python format 格式化函数

一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

eg 2 
print("""Content-type: text/html   

<html>
<head>
   <title>Simple Edit</title>
</head>
<body>
   <form method="post" action="simple_edit.cgi" method="POST">
      <textarea name="text" rows="20" cols="20">{}</textarea> <br />
      <input type="submit" >
   </form>
    </body>
</html>
""".format(text))

https://www.runoob.com/python/att-string-format.html

python之格式化输出format()函数使用总结

abspath


In [1]: import os

In [2]: os.path.abspath("w.py")
Out[2]: '/home/evan/data/python/cgi/w.py'

In [3]: ls
1.cgi*  edit.cgi  index.html  powers.py  save.cgi  simple_edit.cgi*  simple_edit.dat  w.py*

https://stackoverflow.com/questions/51520/how-to-get-an-absolute-file-path-in-python

threading

import threading
import requests

# 目标URL列表
urls = [
    "http://www.google.com",
    "http://www.bing.com",
    "http://www.stackoverflow.com",
    # 添加更多URL
]

# 检查URL可达性的函数
def check_url(url):
    try:
        response = requests.get(url, timeout=5)
        if response.status_code == 200:
            print(f"{url} is up and running.")
        else:
            print(f"{url} returned status code {response.status_code}.")
    except requests.RequestException as e:
        print(f"{url} is down. Error: {e}")

# 创建线程列表
threads = []

# 为每个URL创建并启动一个线程
for url in urls:
    thread = threading.Thread(target=check_url, args=(url,))
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

print("All URLs have been checked.")

json

json b站 


In [1]: import json

In [2]: adict = {'user': 'evan','age':20}

In [3]: json.dumps(adict)
Out[3]: '{"user": "evan", "age": 20}'

In [4]: data=json.dumps(adict)

In [5]: data
Out[5]: '{"user": "evan", "age": 20}'

In [6]: type(data)
Out[6]: str
发送 (编码)
***
接收后 转为 py的dict
In [7]: json.loads(data)
Out[7]: {'user': 'evan', 'age': 20}

In [8]: jdata=json.loads(data)

In [9]: type(jdata)
Out[9]: dict

天气预报

https://e.weather.com.cn/mweather/101280101.shtml

广州 01010704
      0101070401 白云
      0101070402 从化
      0101070403 海珠
      0101070404 花都
      0101070405 黄埔
      0101070406 荔湾
      0101070407 萝岗
      0101070408 南沙
      0101070409 番禺
      0101070410 天河
      0101070411 越秀
      0101070412 增城

python for devops

chapter 3

In [1]: import s
hello evan

In [2]: cat s.py
def say_it():
    greeting = 'hello'
    target = 'evan'
    message = f'{greeting} {target}'
    print(message)

say_it()


➜  tmp python argv.py  --a-flag some-value 13 
the 1 argument: 'argv.py'
the 2 argument: '--a-flag'
the 3 argument: 'some-value'
the 4 argument: '13'
➜  tmp cat argv.py 
import  sys
if __name__ == '__main__':
    print(f"the 1 argument: '{sys.argv[0]}'")
    print(f"the 2 argument: '{sys.argv[1]}'")
    print(f"the 3 argument: '{sys.argv[2]}'")
    print(f"the 4 argument: '{sys.argv[3]}'")
➜  tmp

Python项目读取配置方式

常见的是 import configparser

Python项目读取配置的几种方式

python中字典的循环遍历的两种方式

python中字典的循环遍历的两种方式 


1. 只对键的遍历

一个简单的for语句就能循环字典的所有键，就像处理序列一样：

In [1]: d = {'name1' : 'pythontab', 'name2' : '.', 'name3' : 'com'}
   ...: for key in d:
   ...:     print (key, ' value : ', d[key])
   ...: 
name1  value :  pythontab
name2  value :  .
name3  value :  com


2. 对键和值都进行遍历

如果只需要值，可以使用d.values，如果想获取所有的键则可以使用d.keys。

如果想获取键和值d.items方法会将键-值对作为元组返回，for循环的一大好处就是可以循环中使用序列解包。

代码实例：
or key, value in d.items():
    print (key, ' value : ', value)
name1 value : pythontab
name2 value : .
name3 value : com

python3 遍历列表list 四种方法

python3 遍历列表list 四种方法

python for循环巧妙运用（迭代、列表生成式）

Python 列表(List) 的三种遍历(序号和值)方法

python字典遍历的几种方法


python文件操作

python读取文件

python:如何将文件逐行读取到列表中?

python 读取文本文件内容转化为python的list

python 四种逐行读取文件内容的方法

Python 函数返回值

Python 函数返回值

py linux系统管理

In [6]: [item for item in os.listdir(os.path.expanduser('/tmp')) if os.path.isdir(item)]
Out[6]: []

In [7]: [item for item in os.listdir(os.path.expanduser('/tmp')) if os.path.isdir(item)]
Out[7]: []

打印最常用10条命令
import os 
from collections import Counter

c = Counter()

# 读取bash历史记录文件并统计命令频率
with open(os.path.expanduser('~/.bash_history')) as f:
    for line in f:
# whith open(os.path.expanduser(' ~/.bash_history')) as f:

        cmd = line.strip().split()
        if cmd:
            c[cmd[0]] += 1
            print(c.most_common(10))



# with open('example.txt', 'r') as file:
#     content = file.read()
#     print(content)

# [('ls', 352), ('cd', 309), ('bash', 161), ('cat', 114), ('vim', 78), ('sudo', 54), ('vi', 46), ('geany', 33), ('ssh', 31), ('python3', 27)]
# [('ls', 352), ('cd', 309), ('bash', 161), ('cat', 114), ('vim', 78), ('sudo', 54), ('vi', 46), ('geany', 33), ('ssh', 31), ('python3', 27)]
# [('ls', 352), ('cd', 309), ('bash', 162), ('cat', 114), ('vim', 78), ('sudo', 54), ('vi', 46), ('geany', 33), ('ssh', 31), ('python3', 27)]

def  execute_cmd(cmd):
    p = subprocess.Popen(cmd, 
                         shell=True, 
                         stdin=subprocess.PIPE, 
                         stdout=subprocess.PIPE, 
                         stderr=subprocess.PIPE)
    stdout,stderr = p.communicate()
    if p.returncode != 0:
        return p.returncode, stderr
    return p.returncode, stdout


    函数定义
        def execute_cmd(cmd):定义了一个名为execute_cmd的函数，它接受一个参数cmd，这个参数应该是一个表示命令的字符串或者是一个可以被当作命令执行的对象（在shell=True的情况下）。
    subprocess.Popen调用
        p = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            这行代码使用subprocess模块创建了一个新的子进程来执行命令。
            shell=True表示命令将在一个 shell 环境中执行。这使得可以执行一些复杂的 shell 命令，比如包含管道、重定向等操作的命令。
            stdin=subprocess.PIPE、stdout=subprocess.PIPE和stderr=subprocess.PIPE分别表示将子进程的标准输入、标准输出和标准错误流连接到管道，以便可以获取和处理这些输出和错误信息。
    p.communicate调用
        stdout,stderr = p.communicate()
            这个方法用于与子进程进行通信，它会等待子进程完成，并返回一个包含标准输出和标准错误的元组。
            在这里，stdout将获取子进程的标准输出内容，stderr将获取子进程的标准错误内容。
    返回值处理
        if p.returncode!= 0:
            这里检查子进程的返回码。如果返回码不为 0，说明命令执行过程中出现了错误。
            在这种情况下，return p.returncode, stderr会返回子进程的返回码和标准错误信息。
        return p.returncode, stdout
            如果子进程的返回码为 0，说明命令执行成功，此时会返回子进程的返回码和标准输出信息。


这段代码的主要功能是执行一个命令，并根据命令执行的结果返回相应的信息。如果命令执行成功，返回命令的返回码和标准输出；如果命令执行失败，返回命令的返回码和标准错误。


depoly_mongodb.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
from  __future__ import print_function
import os
import shutil 
import subprocess
import tarfile 

def  execute_cmd(cmd):
    p = subprocess.Popen(cmd, 
                         shell=True, 
                         stdin=subprocess.PIPE, 
                         stdout=subprocess.PIPE, 
                         stderr=subprocess.PIPE)
    stdout,stderr = p.communicate()
    if p.returncode != 0:
        return p.returncode, stderr
    return p.returncode, stdout

def unpackage_mongo(package, package_dir):
    unpackage_dir = os.path.splitext(package)[0]
    if os.path.exists(package_dir):
        shutil.rmtree(package_dir)

    if os.path.exists(papckage_dir):
        shutil.rmtree(package_dir)

    t = tarfile.open(package,'r:gz')
    t.extractall('.')

    shutil.move(unpackage_dir, package_dir)

def create_datadir(data_dir):
    if os.path.exists(data_dir):
        shutil.rmtree(data_dir)
    os.makedirs(data_dir)

def forma_mongod_command(package_dir, data_dir, logfile):
    mongod = os.path.join(package_dir, 'mongod')
    mongod_format =  """{0} --fork --dbpath {1} --logpath {2}"""
    return mongod_format.format(mongod, data_dir, logfile)

def start_mongo(cmd):
    returncode, out = execute_cmd(cmd)
    if returncode != 0:
        raise SystemExit('execute {0} error :{1}'.format(cmd, out))
    else:
        print('execute {0} success'.format(cmd))


def main():
    package = 'mongodb-linux-x86_64-debian11-5.0.29.tgz'
    #package = 'https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.2.10.tgz'
    curl_dir = os.path.abspath('.')
    package_dir  =  os.path.join(curl_dir, 'mongo')
    data_dir = os.path.join(cur_dir, 'mongodata')
    logfile = os.path.join(data_dir,'mongod.log')

    if not os.paht.exists(package):
        raise SystemExit(" {0} not found ", format(package))
    
    unpackage_mongo(package, package_dir)

if __name__ ==  '__main__':
    main()


# 代码解读  unpackage_dir = os.path.splitext(package)[0]
# 以下是对这段代码的解读：

#     os.path.splitext(package)
#         这是 Python 中os.path模块提供的一个函数。它的作用是将文件名（这里是package变量所代表的文件名）拆分成文件名和扩展名两部分。
#         例如，如果package是"example.txt"，那么os.path.splitext(package)将返回("example", ".txt")。
#     unpackage_dir = os.path.splitext(package)[0]
#         这里取os.path.splitext(package)返回结果的第一个元素。
#         继续上面的例子，如果package是"example.txt"，那么unpackage_dir将被赋值为"example"。
#         其目的通常是获取文件名中除去扩展名的部分，可能是为了进一步操作，比如创建一个与该文件名（除去扩展名）相关的目录等。

文本处理

In [39]: import os
p75
In [40]: [ item for item in os.listdir('.') if item.endswith('.py')]
Out[40]: 
['1.py',
 'checkprocess.py',
 'dump.py',
 'judge.py',
 'rename.py',
 'devresize.py',


# 在不在另外一个str 中用in or not in 
In [45]: 'in' in s
Out[45]: True

In [46]: "".join(['a','b','c'])
Out[46]: 'abc'

In [47]: str.join?
Signature: str.join(self, iterable, /)
Docstring:
Concatenate any number of strings.

The string whose method is called is inserted in between each given string.
The result is returned as a new string.

Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
Type:      method_descriptor


In [54]: from collections import Counter

In [55]: c = Counter('abcba')

In [56]: c
Out[56]: Counter({'a': 2, 'b': 2, 'c': 1})

In [57]: c['a'] += 1

In [58]: c
Out[58]: Counter({'a': 3, 'b': 2, 'c': 1})

In [59]: c.most_common(2)
Out[59]: [('a', 3), ('b', 2)]


字符串格式化
In [5]: "{} is better than {}. {} is better than {}.". format('Beaufiful', 'ugly', 'explicit', 'implicit')
Out[5]: 'Beaufiful is better than ugly. explicit is better than implicit.'

re

In [6]: import re

In [7]: data = "what is the difference between pyuthon 2.7.12 and python 3.6 ?"

In [10]: re.findall('python [0-9]\.[0-9]\.[0-9]',data)
<>:1: SyntaxWarning: invalid escape sequence '\.'
<ipython-input-10-15bd1c311994>:1: SyntaxWarning: invalid escape sequence '\.'
  re.findall('python [0-9]\.[0-9]\.[0-9]',data)
Out[10]: []

In [11]: re.findall('python',data)
Out[11]: ['python']

import re  

def main():
    pattern = "[0-9]+"
    re_obj = re.compile(pattern)
    with open('data.txt') as f:
        for line in f:
            print(re_obj.findall(line))

if __name__ == '__main__':
    main()


#     ➜  tmp py3 re_compile.py
# ['12234']
# ['22222']
# ['3333']

# ➜  tmp cat data.txt 
# dafasf12234
# ddd22222
# 3333dddd%  

>>> import re 
>>> import re,requests
>>> r = requests.get('https://news.ycombinator.com/')
>>> 
>>> re.findall('"(https?://.*?)"',r.content)
match.group(1)

    match.group(1)的含义
        在 Python 的re（正则表达式）模块中，当使用re.search()、re.match()或re.finditer()等函数进行正则表达式匹配时，会返回一个匹配对象（通常用match表示）。
        match.group(1)用于获取正则表达式中第一个分组（group）匹配到的内容。
        例如，假设有正则表达式r'(abc)(def)'，当用这个正则表达式对字符串'abcdef'进行匹配时：
            整个正则表达式(abc)(def)会匹配整个'abcdef'字符串。
            match.group(0)会返回整个匹配的字符串，即'abcdef'。
            match.group(1)会返回第一个分组(abc)匹配到的字符串，即'abc'。
            match.group(2)会返回第二个分组(def)匹配到的字符串，即'def'。
        如果正则表达式中的分组没有匹配到任何内容，那么调用match.group(1)（或其他分组索引）可能会引发一个IndexError。


例如，考虑以下代码：



import re

pattern = r'(\d+)\s+(\w+)'
string = '123 abc'
match = re.search(pattern, string)
if match:
    print(match.group(0))  # 输出: 123 abc
    print(match.group(1))  # 输出: 123
    print(match.group(2))  # 输出: abc

chapter 3

Click https://click.palletsprojects.com/en/stable/

chapter 5

E5

In [2]: import glob

In [3]: glob.glob('*.py') Out[3]: ['1.py', 

'deploy-mongo.py',
'2.py',
'moni-php.py',
'c.py',
'errmv.py',
'with.py',
'test__file__.py']

os.walk 

import os 
import fnmatch 

pys=['*.py','*.pyw']
matches = []

for root, dirnames, filenames in os.walk(os.path.expanduser("/home/evan/data/tmp/py")):
    for extensions in pys:
        for filename in fnmatch.filter(filenames, extensions):
            matches.append(os.path.join(root, filename))

print(matches)

'/home/evan/data/tmp/py/md5.py', '/home/evan/data/tmp/py/pe.py', '/home/evan/data/tmp/py/get10.py', '/home/evan/data/tmp/py/pscp.py', '/home/evan/data/tmp/py/p.py', '/home/evan/data/tmp/py/read_from_fileinput2.py', '/home/evan/data/tmp/py/read_stdin2.py', '/home/evan/data/tmp/py/pp.py', '/home/evan/data/tmp/py/read_from_fileinput.py', '/home/evan/data/tmp/py/default_logging.py']

shutil

In [4]: shutil.copy('1.txt','2.txt') Out[4]: '2.txt'

In [5]: shutil.copytree('__pycache__','dd') Out[5]: 'dd'

chapter 8

8.4 DNS
In [3]: import dns.resolver

In [4]: data=dns.resolver.query('linuxsa.org','A')
<ipython-input-4-f5f420be195e>:1: DeprecationWarning: please use dns.resolver.resolve() instead
  data=dns.resolver.query('linuxsa.org','A')

In [5]: for item in data.response.answer:
   ...:     print(item)
linuxsa.org. 300 IN A 104.21.72.8
linuxsa.org. 300 IN A 172.67.173.102


➜  ~ dig linuxsa.org 

; <<>> DiG 9.16.15-Debian <<>> linuxsa.org
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 10748
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;linuxsa.org.			IN	A

;; ANSWER SECTION:
linuxsa.org.		274	IN	A	172.67.173.102
linuxsa.org.		274	IN	A	104.21.72.8

chapter 11

上下文


with open('file1','r') as source, open('file2','w') as target:
    target.write(source.read())

mysql




import os
import pymysql  as db 
# if os.getenv('DB','MySQL') == 'MySQL':
#     import MySQLdb as db 
# else:
#     import sqlite3 as db 

def get_conn(**kwargs):
    if os.getenv('DB', 'MySQL') == 'MySQL':
        return db.connect(host=kwargs.get('host', 'localhost'),
            user=kwargs.get('user'),
            passwd=kwargs.get('passwd'),
            port=kwargs.get('port', 3306),
            db=kwargs.get('db'))
    else:
        return db.connect(database=kwargs.get('db'))

def main():
    conn = get_conn(host='127.0.0.1',
            user='root',
            passwd='evan2240881',
            port=3306,
            db='bbs')

    # get cursor object
    cur = conn.cursor()

    # execute SQL statement
    cur.execute("select * from messages")
    print(cur.fetchall())

    # close resources
    cur.close()
    conn.close()


if __name__ == '__main__':
    main()


#   tmp py3 connect_mysql.py
# ((1, '', '', None, ''), (2, '2', 'evan', None, 'evan'))

range

Python3 range() 函数用法

learn

py作为很多开发项目的辅助语言现在来说会更流行一些，不管是github还是其他地方。所以，你能找到的帮助，解决问题的思路也比perl广。
追问

python 自学容易么，可否推荐基本书看看

追答

首先我推荐你从这边开始入门，我以前也是这边看。http://woodpecker.org.cn/abyteofpython_cn/chinese/index.html， 自学容易的。

，不需要急，等大部分了解后，并且使用py写脚本一段时间之后，你会开始需要更多模块的用法，这时候到 https://docs.python.org/2.7/ 这里查。 
书的话，我觉得如果你想成为语法大师的话，O'REILLY 的 跟 这两本，

不会的问题，用google搜，特别是Stack Overflow 的站点上搜往往能找到答案。
当觉得已经对py很熟悉之后，可以看别人的py项目。然后用一些好用的框架比如django啥的，那么就合格了。然后模块就是越用越熟悉

Apr 2024

tuple
英 [tjʊpəl; ˈtʌpəl] 美 [ˈtjʊpəl; ˈtʌpəl]    n. [计] 元组，重数



安装 VS Code Python

Python VScode 配置

Python AI 编程助手

str

In [3]: s = "hello"

In [4]: s[0] = 'H'
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-d6f3b193531a> in <module>
----> 1 s[0] = 'H'

TypeError: 'str' object does not support item assignment

In [5]: s = 'H' + s[1:]

In [6]: s
Out[6]: 'Hello'

In [7]: s = "Hello, world"

In [8]: s[:5]
Out[8]: 'Hello'

In [9]: s[::-1]
Out[9]: 'dlrow ,olleH'

In [10]: ''.join(reversed(s))
Out[10]: 'dlrow ,olleH'

In [11]:

list

与Python字符串不一样的是，列表中的元素是可以改变的 



def reverseWords(input):
    inputWords = input.split()
    inputWords=inputWords[-1::-1]

    output= ' '.join(inputWords)
    return output

if __name__ ==  "__main__":
    input =  'I love evan'
    rw = reverseWords(input)
    print(rw)

 '''
 
 evan love I
 
     # 翻转字符串
    # 假设列表 list = [1,2,3,4],  
    # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
https://www.runoob.com/python3/python3-data-type.html    
 '''

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同 

tup2 = (20,) # 一个元素，需要在元素后添加逗号

如果你想创建只有一个元素的元组，需要注意在元素后面添加一个逗号，以区分它是一个元组而不是一个普通的值，这是因为在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。

如果不添加逗号，如下所示，它将被解释为一个普通的值而不是元组：

not_a_tuple = (42)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

https://www.runoob.com/python3/python3-tuple.html

Dictionary

Python3 条件控制

match...case

Python 3.10 增加了 match...case 的条件判断，不需要再使用一连串的 if-else 来判断了 

def http_error(status):
    match status:
        case 400:
            return "bad request"
        case 404:
            return "not Found"
        case 418:
            return "I am a  teapot"
        case _:
            return "something's wrong with the internet"
        
mystatus=400
print(http_error(mystatus))    

# bad request

Python3 循环语句

斐波纳契数列

n=3
a, b = 0,1 
for  i in range(n):
    print("斐波纳契数列为%d"%(b))
    a,b = b,a+b 
    print("a is %d  b is %d" %(a,b))
''' 
其中代码 a, b = b, a+b 的计算方式为先计算右边表达式，然后同时赋值给左边，等价于：

n=b
m=a+b
a=n
b=m
'''

[Running] /usr/bin/python3  "/home/evan/tmp/py/2.py"
斐波纳契数列为1
a is 1  b is 1
斐波纳契数列为1
a is 1  b is 2
斐波纳契数列为2
a is 2  b is 3


Python 推导式

Python3 迭代器与生成器

Python3 函数






def area(width, height):
    return  width * height 

def print_welcome(name):
    print("welcome",name)

print_welcome("evan")
w = 4 
h = 5  
print("width =", w, "height =", h , "area =", area(w,h))

welcome evan
width = 4 height = 5 area = 20



x = lambda a : a + 10
print(x(5))
# Output: 15

强制位置参数

https://www.runoob.com/python3/python3-function.html

https://zhuanlan.zhihu.com/p/412273465

参数传递

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。



参数

以下是调用函数时可使用的正式参数类型： 

   必需参数
   关键字参数
   默认参数
   不定长参数
必需参数
关键字参数

键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值 

def printinfo( name, age):
    print ("name:", name)
    print ("age:", age )

printinfo( age=40, name="nick")

name: nick
age: 40
默认参数

def printinfo( name, age=33):
    print ("name:", name)
    print ("age:", age )

printinfo( age=40, name="nick")
print("88888888888888")
printinfo( name="evan")

name: nick
age: 40
88888888888888
name: evan
age: 33


不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。


def printinfo( arg1, *vartuple ):
    print("输出")
    print(arg1)
    print(vartuple)

printinfo( 70,60,50)

输出
70
(60, 50)

 还有一种就是参数带两个星号 **基本语法如下：

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了两个星号 ** 的参数会以字典的形式导入
def printinfo( arg1, **vardict ):
    print("输出")
    print(arg1)
    print(vardict)

printinfo( 70,a=33,b=50)

输出
70
{'a': 33, 'b': 50}
匿名函数

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。 

   lambda 只是一个表达式，函数体比 def 简单很多

语法

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

设置参数 a 加上 10:
实例
x = lambda a : a + 10
print(x(5))

sum = lambda arg1, arg2: arg1 + arg2 

print("相加后的value" ,sum( 10, 20))
print("相加后的value" ,sum( 20, 30))
return 语句
def sum( arg1, arg2 ):
    total = arg1 + arg2 
    print("函数内 : ",total)
    return  total  

total = sum(10,20)
print("函数外",total)
函数内 :  30
函数外 :  30
强制位置参数


Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

Python lambda（匿名函数）


# x=lambda a : a  + 10 
# print(x(5))

# sum = lambda arg1, arg2: arg1 + arg2 

# print("相加后的value" ,sum( 10, 20))
# print("相加后的value" ,sum( 20, 30))

# def sum( arg1, arg2 ):
#     total = arg1 + arg2 
#     print("函数内 : ",total)
#     return  total  

# total = sum(10,20)
# print("函数外",total)
# 函数内 :  30
# 函数外 :  30

# x = lambda a : a + 1 
# print(x(2))

# x = lambda a, b , c : a + b + c 
# print(x(5,6,2))

# numbers = [1,2,3,4,5]
# squared =  list(map(lambda x: x**2,numbers))
# print(squared)

# # Output: [1, 4, 9, 16, 25]

# numbers=[1,2,3,4,5,6,7,8]
# even_numbrs = list(filter(lambda x: x % 2  ==0, numbers))
# print(even_numbrs)

# # Output: [2, 4, 6, 8]

from  functools  import reeuce  

numbers = [1,2,3,4,5]
product = reduce(lambda x,y: x*y, numbers)
print(product)

# Output: 120


Python 装饰器

https://www.runoob.com/python3/python-decorators.html 

语法

def decorator_function(original_function):
    def wrapper(*args, **kwargs):
        # 这里是在调用原始函数前添加的新功能
        before_call_code()
        result = original_function(*args, **kwargs)

        # 这里是在调用原始函数后添加的新功能
        after_call_code()
        return result
    return wrapper

# 使用装饰器
@decorator_function
def target_function(arg1, arg2):
    pass  # 原始函数的实现


使用装饰器

装饰器通过 @ 符号应用在函数定义之前，例如：

@time_logger
def target_function():
    pass

等同于：

def target_function():
    pass
target_function = time_logger(target_function)

这会将 target_function 函数传递给 decorator 装饰器，并将返回的函数重新赋值给 target_function。从而，每次调用 target_function 时，实际上是调用了经过装饰器处理后的函数。

通过装饰器，开发者可以在保持代码整洁的同时，灵活且高效地扩展程序的功能


def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print("Hello, " + name)

greet("Evan")

Hello, Evan
Hello, Evan
Hello, Evan

Python3 数据结构

Python3 模块

Python3 File(文件) 方法

Python3 面向对象

class MyClass:
    i = 12345
    def f(self):
        return 'hello evan'
    
x = MyClass()

print("Myclass类的属性i 为：",x.i)
print("Myclass类的方法f 的返回值为：",x.f())

Myclass类的属性i 为： 12345
Myclass类的方法f 的返回值为： hello evan
取自“http://wiki.linuxchina.net/index.php?title=Python基础&oldid=12309”