精华内容
下载资源
问答
  • python中集合类,有列表,元组,字典和集合四种。定义方式分别为: List = [] Turple = () Dict = {key: value} Set = {} 作为JAVA程序员看来,python中集合与JAVA中集合类其实很相似,用着肯定是python更好用...

    PYTHON笔记一

    Note one**

    python中的集合类,有列表,元组,字典和集合四种。定义方式分别为:
    List = []
    Turple = ()
    Dict = {key: value}
    Set = {}
    作为JAVA程序员看来,python中的集合与JAVA中的集合类其实很相似,用着肯定是python更好用,个人认为优点如下:1.没有强定义类型。2.提供了很方便的处理统计运算方式。3.可能是语言的优点,少量代码就能实现复杂逻辑。

    Note two

    https://docs.python.org/zh-cn/3.7/library/os.html
    作为脚本语言,os模块在脚本中时有用到,os模块能完成查看当前操作系统,执行系统命令,文件管理之类功能。使用方法也很简单。如图所示就能进行使用,具体有哪些方法参见上述文档。

    上图中使用到了os.getcwd()查看当前路径的方法。
    os.getlogin()查看当前用户方法。
    os.getpid()查看当前进程号方法。

    Note three

    这点感觉超级nice,让数字运算,数字展示更加的简洁,直观。通过数字之间用字符隔开的形式就能做到。代码如下:

    # how to make a number more clearly
    num1 = 10000000000
    num2 = 1000000
    total = num1 +num2
    # print(total)
    
    var1 = 10_000_000_000
    var2 = 1_000_000
    # print(f'{total:,}')
    

    Note four

    告别四句式if else吧:通过语句
    expression define if condition else define远离了四行的if else,实例如下:
    condition = True

    if condition:
        x = 1
    else:
        x = 0
    
    x = 1 if condition else 0
    

    Note five:

    能用contextManger的时候就不要用open的方式,contextManger会在资源不再使用的时候替我们关闭所有资源,代码实列如下:

    # f = open('test.txt', 'r')
    # file_contents = f.read()
    # f.close()
    #
    # words = file_contents.split(' ')
    # word_count = len(words)
    # print(word_count)
    
    # use a context manager
    with open('test.txt', 'r') as f:
        file_content = f.read()
    words = file_content.split(' ')
    word_count = len(words)
    # print(word_count)
    

    代码中未注释的是使用contextManger的用法,唯一好处在于自动完成资源的关闭。毕竟使用python简洁是一种追求。我在写python代码的时候其实python代码的可读性个人感觉弱于java。

    Note six

    还需要外部定义遍历中的次数吗???代码实列如下;

    list = ['liubh1', 'liubh2', 'liubh3', 'liubh4']
    index = 0
    for name in list:
        print(index, name)
        index += 1
    
    for index, name in enumerate(list, start=1):
        print(index, name)
    

    试试使用enumerate吧,start表示遍历开始从多少开始计数。通过这中方式就可以不需要再外部定义index = 0。极致代码简洁度。Of course,在外部定义遍历索引也是一种很好的方式。

    Note seven

    列表如何实现一一对应,这个我大学时候写估计还在用index每个list都去获取相应值,然后排在一起,其实有更简洁的方法,不能说它更好,但更简洁,逼格以下就上升了,代码示例如下:

    names = ['马云', '王健林', '麻花疼', '雷军']
    companies = ['阿里', '万达', '腾讯', '小米']
    cities = ['杭州', '大连', '深圳', '武汉']
    for index, name in enumerate(names):
        company = companies[index]
        print(f'{name}  belongs to {company}')
    
    for name, company, city in zip(names, companies, cities):
        print(f'{name}  belongs to {company} from {city}')
    

    还是通过使用enumerate方法,当集合更多的时候可以使用zip()方法,想传多少集合都可以。

    Note eight

    直接看代码示例:

    # a, b = (1, 2)
    # print(a)
    
    a, *b, c = (1, 2, 6, 9)
    
    # print(b)
    

    我记得在上大学时经常用到过这样的思路,某个列表或元组要取中间部分,可能第一时间想到的把开头或者尾部取掉,其实通过*号在变量定义的时候就能完成这种操作了。

    Note nine

    在做java程序员后感觉自己才开始慢慢的懂了,理解了面向对象的思维,python中也有面向对象的概念。通过setattr()和getattr()就能完成对象属性的操作了,这个真的超级棒。
    代码实列如下:

    class Person():
        pass
    
    person = Person()
    key = 'age'
    value = '20'
    setattr(person, key, value)
    first = getattr(person, key)
    
    print(first)
    
    person_info = {'age': "20", "name": "liubh"}
    
    for key, value in person_info.items():
        setattr(person, key, value)
    
    for key in person_info.keys():
        value = getattr(person, key)
    

    ###It’a tutural from Ytu,I don’t know can I put the address here,So you can common it about your email so we can get a communication.
    一分钟搞定csv统计。使用了非常强大的Counter()。

    import csv
    #
    #
    from collections import defaultdict, Counter
    # with open('data/survey_results_public.csv', encoding="utf-8") as f:
    #     csv_reader = csv.DictReader(f)
    #     yes_count = 0
    #     no_count = 0
    #     counts = {
    #         'Yes': 0,
    #         'NO': 0
    #     }
    #     counts = defaultdict(int)
    #     counts = Counter()
    #     for line in csv_reader:
    #         print(line['Hobbyist'])
    #         if line['Hobbyist'] == "Yes":
    #             yes_count += 1
    #         elif line['Hobbyist'] == "No":
    #             no_count += 1
    #         counts[line['Hobbyist']] += 1
    # total = yes_count + no_count
    # yes_pct = (yes_count / total) * 100
    # yes_pct = round(yes_pct, 2)
    # no_pct = (no_count / total) * 100
    # no_pct = round(no_pct, 2)
    # print(f'Yes:{yes_pct}%')
    # print(f'No:{no_pct}%')
    # print(counts)
    
    
    # with open('data/survey_results_public.csv', encoding='utf-8') as f:
    #     reader = csv.DictReader(f)
    #     language_counter = Counter()
    #     total = 0
    #     for data in reader:
    #         languages = data['LanguageWorkedWith'].split(';')
    #         language_counter.update(languages)
    # #         most_common查看排名
    #         total += 1
    # print(language_counter.most_common(5))
    # for language, value in language_counter.most_common(5):
    #     language_pct = (value / total) * 100
    #     language_pct = round(language_pct, 2)
    #     print(f'{language}: {language_pct}%')
    
    
    with open('data/survey_results_public.csv', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        dev_type_info = {}
        total = 0
        for data in reader:
            dev_types = data['DevType'].split(';')
            for dev_type in dev_types:
                dev_type_info.setdefault(dev_type, {
                    'total': 0,
                    'language_counter': Counter()
                })
                languages = data['LanguageWorkedWith'].split(';')
                dev_type_info[dev_type]['language_counter'].update(languages)
                dev_type_info[dev_type]['total'] += 1
    for dev_type, info in dev_type_info.items():
        print(dev_type)
        for language, value in info['language_counter'].most_common(5):
            language_pct = (value / info['total']) * 100
            language_pct = round(language_pct, 2)
            print(f'----------{language}:{language_pct}%')
    

    注释第二部分运行结果如下:
    JavaScript: 66.63%
    HTML/CSS: 62.4%
    SQL: 53.49%
    Python: 41.0%
    Java: 40.41%

    2019排名前五的变成语言分别是JS,HTML/CSS,SQL.Python,JAVA。

    附代码,对2019 developer survey。Developer中不同岗位什么最受欢迎。

    以上代码运行结果如下,展示的是程序员中的不同工种最常使用的编程语言:
    ----------HTML/CSS:54.9%
    ----------Python:51.09%
    ----------JavaScript:50.58%
    ----------Java:42.71%
    ----------C++:35.02%
    Developer, desktop or enterprise applications
    ----------JavaScript:67.84%
    ----------HTML/CSS:64.55%
    ----------SQL:63.56%
    ----------C#:53.69%
    ----------Java:44.69%
    Developer, front-end
    ----------JavaScript:87.72%
    ----------HTML/CSS:83.62%
    ----------SQL:58.65%
    ----------Java:37.6%
    ----------PHP:35.94%
    Designer
    ----------HTML/CSS:78.88%
    ----------JavaScript:78.33%
    ----------SQL:60.18%
    ----------PHP:40.23%
    ----------Java:39.44%
    Developer, back-end
    ----------JavaScript:72.23%
    ----------HTML/CSS:65.42%
    ----------SQL:64.01%
    ----------Java:44.03%
    ----------Python:40.67%
    Developer, full-stack
    ----------JavaScript:86.15%
    ----------HTML/CSS:78.94%
    ----------SQL:65.54%
    ----------Java:40.74%
    ----------Bash/Shell/PowerShell:37.91%
    Academic researcher
    ----------Python:61.06%
    ----------HTML/CSS:55.87%
    ----------JavaScript:54.25%
    ----------SQL:47.55%
    ----------Java:42.26%
    Developer, mobile
    ----------JavaScript:67.72%
    ----------HTML/CSS:62.46%
    ----------Java:57.21%
    ----------SQL:51.27%
    ----------C#:34.34%
    Data or business analyst
    ----------SQL:73.88%
    ----------HTML/CSS:62.11%
    ----------JavaScript:61.33%
    ----------Python:51.86%
    ----------Bash/Shell/PowerShell:38.43%
    Data scientist or machine learning specialist
    ----------Python:79.33%
    ----------SQL:58.44%
    ----------JavaScript:51.38%
    ----------HTML/CSS:50.43%
    ----------Bash/Shell/PowerShell:44.49%
    Database administrator
    ----------SQL:81.7%
    ----------JavaScript:78.11%
    ----------HTML/CSS:76.19%
    ----------Bash/Shell/PowerShell:45.2%
    ----------PHP:44.16%
    Engineer, data
    ----------SQL:66.75%
    ----------Python:64.31%
    ----------JavaScript:60.13%
    ----------HTML/CSS:56.47%
    ----------Bash/Shell/PowerShell:48.55%
    Engineer, site reliability
    ----------JavaScript:69.43%
    ----------Bash/Shell/PowerShell:64.05%
    ----------HTML/CSS:62.79%
    ----------SQL:61.37%
    ----------Python:59.23%
    Developer, QA or test
    ----------JavaScript:73.38%
    ----------HTML/CSS:70.31%
    ----------SQL:64.81%
    ----------Bash/Shell/PowerShell:45.73%
    ----------Java:45.23%
    DevOps specialist
    ----------JavaScript:73.67%
    ----------HTML/CSS:66.66%
    ----------SQL:64.56%
    ----------Bash/Shell/PowerShell:63.98%
    ----------Python:52.44%
    Developer, game or graphics
    ----------JavaScript:69.02%
    ----------HTML/CSS:66.37%
    ----------C#:54.31%
    ----------SQL:48.91%
    ----------C++:47.85%
    Educator
    ----------JavaScript:70.15%
    ----------HTML/CSS:70.15%
    ----------SQL:56.92%
    ----------Python:47.02%
    ----------Java:44.26%
    Student
    ----------HTML/CSS:68.13%
    ----------JavaScript:63.53%
    ----------Java:54.37%
    ----------Python:54.37%
    ----------SQL:51.83%
    Engineering manager
    ----------JavaScript:72.35%
    ----------HTML/CSS:65.02%
    ----------SQL:60.4%
    ----------Bash/Shell/PowerShell:49.1%
    ----------Python:46.86%
    Senior executive/VP
    ----------JavaScript:75.94%
    ----------HTML/CSS:71.81%
    ----------SQL:64.12%
    ----------Bash/Shell/PowerShell:46.8%
    ----------Python:46.37%
    System administrator
    ----------JavaScript:73.45%
    ----------HTML/CSS:72.57%
    ----------SQL:67.94%
    ----------Bash/Shell/PowerShell:58.44%
    ----------Python:51.36%
    Developer, embedded applications or devices
    ----------JavaScript:60.89%
    ----------HTML/CSS:57.75%
    ----------C++:51.08%
    ----------SQL:50.97%
    ----------Python:50.95%
    Product manager
    ----------JavaScript:75.0%
    ----------HTML/CSS:71.92%
    ----------SQL:63.42%
    ----------Python:39.63%
    ----------Bash/Shell/PowerShell:38.96%
    Scientist
    ----------Python:69.48%
    ----------HTML/CSS:51.04%
    ----------JavaScript:48.77%
    ----------Bash/Shell/PowerShell:47.83%
    ----------SQL:44.21%
    Marketing or sales professional
    ----------HTML/CSS:76.82%
    ----------JavaScript:71.79%
    ----------SQL:58.97%
    ----------PHP:44.21%
    ----------Python:38.26%

    展开全文
  • 圣诞节课程笔记一、列表常见操作1.L.append(object) 在列表末尾添加新元素2.L.count(object) 统计元素在列表中出现次数 列表中没有时返回03.L.extend(iterable) 用新列表拓展原来的列表,和L.append比优点是可以...

    在这里插入图片描述

    一、列表常见操作

    1.L.append(object) 在列表末尾添加新的元素

    li_1 = list('逻辑教育')
    li_1.append('是我家')
    print(li_1)
    # 注意:使用list创建列表 字符串分解成各个元素,而L.append用法只能给列表添加一个元素,想要添加多个元素只能重复添加,不能使用该方法用逗号隔开。
    li_1.append('是', '我', '家')
    print(li_1)
    li_1.append(['是', '我', '家'])
    print(li_1)
    # 区别于接下来讲的L.extend方法
    
    ['逻', '辑', '教', '育', '是我家']
    
    报错
    TypeError: append() takes exactly one argument (3 given)
    append()只接受一个参数(给了3个)
    
    ['逻', '辑', '教', '育', '是我家', ['是', '我', '家']]
    

    2.L.count(object) 统计元素在列表中出现的次数 列表中没有时返回0

    li_2 = list('元歌1433223')
    print(li_2.count('3'))
    # 注意:在统计时一定要确定好元素在列表中的类型
    li_3 = [1, 1, 1, '1', '1']
    print(li_3.count(1))
    # 确定其时int类型还是str类型
    
    3
    3
    

    3.L.extend(iterable) 用新列表拓展原来的列表,和L.append比优点是可以同时拓展多个元素。

    li_4 = list('逻辑教育')
    li_4.extend(['是', '我', '家'])
    print(li_4)
    li_4.extend([['是', '我', '家']])
    print(li_4)
    
    ['逻', '辑', '教', '育', '是', '我', '家']
    ['逻', '辑', '教', '育', '是', '我', '家', ['是', '我', '家']]
    

    4.L.index(value) 从列表中找出某个值第一个匹配项的索引位置

    li_5 = list('元歌1433223')
    print(li_5.index('2'))
    
    6
    

    5.L.insert(index, object) 将元素插入列表

    i_6 = ['小姐姐', '请加', '我的', '微信']
    li_6.insert(0, '漂亮的')
    print(li_6)
    
    
    ['漂亮的', '小姐姐', '请加', '我的', '微信']
    

    6.L.pop([index]) 删除列表中的元素,可添加索引,默认为最后一个元素

    li_7 = list('法海你不懂爱')
    li_7.pop()
    print(li_7)
    li_7.pop(0)
    print(li_7)
    
    ['法', '海', '你', '不', '懂']
    ['海', '你', '不', '懂']
    

    7.L.remove(value) 移除列表中某个值的第一个匹配项

    li_8 = list('没有女朋女友女')
    li_8.remove('女')
    print(li_8)
    
    ['没', '有', '朋', '女', '友', '女']
    

    8.L.reverse() 反向列表中元素

    li_9 = list('love')
    li_9.reverse()
    print(li_9)
    
    ['e', 'v', 'o', 'l']
    

    9.L.sort(reverse=False) 对原列表进行排序

    li_10 = [3, 8, 1, 6, 5]
    li_10.sort()
    print(li_10)
    # 字母根据Acll码
    
    [1,3,5,6,8]
    

    10L.clear() 清空列表

    li_11 = list('love')
    li_11.clear()
    print(li_11)
    
    []
    

    二、元组

    元组也是 序列结构,但是是一种 不可变序列,你可以简单的理解为内容不可变的 列表。除了在内部元素不可修改的区别外,元组和列表的用法差不多。

    1.元组与列表相同的操作

    1.使用 方括号加下标 访问元素
    2.切片(形成新元组对象)
    3.tuple.count() / tuple.index()
    4.python内置函数:reversed(),sorted()
    5.加法及乘法

    2.元组中不允许的操作

    1.不允许 修改 、新增 元素。(一级)
    2.不允许 删除 某个元素(但可以删除整个元组) 实际上,元组没有任何会对内部元素发生 修改 动作的方法。例如,元组没有 remove,append,pop 等方法

    tu_1 = ('真', '漂亮', ['old','amy','老师'])
    tu_1[2][0] = '大'
    print(tu_1)
    
    ('真', '漂亮', ['大', 'amy', '老师'])
    

    3.列表元组的相互转换

    li_1 = list('今天圣诞节')
    tu_1 = tuple(li_1)
    print(tu_1)
    li_2 = list(tu_1)
    print(li_2)
    
    ('今', '天', '圣', '诞', '节')
    ['今', '天', '圣', '诞', '节']
    

    三、字典

    Python 的字典数据类型是基于 hash 散列算法实现的,采用 键值对 (key:value) 的形 式,根据 key 的值计算 value 的地址,具有非常快的查取和插入速度。它是一种 可变 对象 ,所以支持修改、插入、删除等操作。

    1.访问字典

    字典是 集合类型,不是序列类型,因此 没有索引下标 的概念,更 没有切片 的 说法。但是,与 list 类似,字典采用把 相应的键 放入 方括号 内获取 对应值 的 方式取值。

    dit = {'name': 'cgt', 'age': 21}
    print(dit['age'])
    
    21
    

    2.字典的增加与修改

    1.字典的键只能是不可变类型

    dit = {['name']: 'cgt', 'age': 21}
    print(dit)
    # 结果报错,因为列表是可变数据类型
    

    2.由于一个 key 只能对应一个值,所以 多次对一个 key 赋值,后面的值会把前面的值覆盖 。

    dit = {'name': '郭德纲','name': '于谦','name':'郭麒麟'}
    print(dit)
    
    {'name': '郭麒麟'}
    

    3.字典常见操作

    D.get(k[,d]) --> 返回指定键的值,如果值不在字典中,则返回default值
    D.items() --> 以列表返回可遍历的(键, 值) 元组对
    D.keys() --> 以列表返回字典所有的键
    D.values() --> 以列表返回字典所有的值

    4.map和zip方法

    1.map

    li_1 = list('12345')
    print(list(map(int, li_1)))
    
    [1, 2, 3, 4, 5]
    

    将li_1列表中的元素映射到int()中,并返回值,不改变原来的列表。

    2.zip

    zip对象:打包,将可迭代对象里面一一对应的元素打包元组进行返回。

    li_k = ('name', 'age', 'address')
    li_v = ('csdn',21,'internet')
    print(list(zip(li_k,li_v)))
    print((dict(zip(li_k,li_v))))
    
    [('name', 'csdn'), ('age', 21), ('address', 'internet')]
    {'name': 'csdn', 'age': 21, 'address': 'internet'}
    

    课后作业

    作业1

    lis1 = [“name”, “author”, “introduce”]
    lis2 = [“NORWEGIAN WOOD”, “Haruki Murakami”, “balalalalal…7”]

    将is1与lis2以键值对的形式呈现。

    答:

    lis1 = ["name", "author", "introduce"]
    lis2 = ["NORWEGIAN WOOD", "Haruki Murakami", "balalalalal...7"]
    print(dict(list(zip(lis1,lis2))))
    
    

    作业2

    Amy_info = {‘hame’: ‘amy’, ‘addr’: ‘hunan’, ‘weight’: 90}获取amy_info的key.value

    Amy_info = {'hame': 'amy', 'addr': 'hunan', 'weight': 90}
    print(Amy_info.items())
    print(Amy_info.keys())
    print(Amy_info.values())
    

    作业3

    生成了N个1~1000之间的随机整数(N<=1000),N是用户输入的,
    对于其中重复的数字,只保留一个,把其余相同的数字去掉,然后再把这些数从小到大排序。

    答:

    import random
    i = 0
    a = int(input('请输入生成随机数的个数:'))
    li_1 = list()
    while i!=a:
        if a == i:
            pass
        else:
            shu = random.randint(1, 1000)
            li_1.append(shu)
            i += 1
    li_2 = list()
    for item in li_1:
        if not item in li_2:
            li_2.append(item)
    li_2.sort()
    print(li_2)
    

    作业4

    字节如何转字符串,字符串如何转字节

    答:

    zj_1 = b'hello amy'
    s_1 = zj_1.decode()
    print(s_1)
    zj_2 = s_1.encode()
    print(zj_2)
    

    作业5

    总结数据类型哪些为可变的哪些为不可变的

    答:可变类型(mutable):列表,字典、集合
    不可变类型(unmutable):数字,字符串,元组

    想学习更多关于python的文章,欢迎专注我们的公众号奥~
    在这里插入图片描述

    展开全文
  • DICOM国际会议暨研讨会:在Adobe Acrobat中直接提供DICOM封装PDF支持(DICOM 3.0增补版104)的优点 随着超过600,000,000份的Adobe Acrobat拷贝广泛应用于建立和阅读以便携文档格式(PDF)保存的文件,PDF正成为真实...
  • 注意:我尝试将答案合并为一个全面的列表。 我在适当地方提到名称,以便在哪里提供信用。有很多方法可以解决这个问题,每个方面都有优点/缺点:纯JSP解决scheme正如上面提到ScArcher2一样,解决这个问题一个...

    注意:我尝试将答案合并为一个全面的列表。 我在适当的地方提到名称,以便在哪里提供信用。

    有很多方法可以解决这个问题,每个方面都有优点/缺点:

    纯JSP解决scheme

    正如上面提到的ScArcher2一样,解决这个问题的一个非常简单的方法就是直接在JSP中实现,如下所示:

    ${person.name}${person.age} ${ageTotal}

    这个解决scheme的问题是JSP变得混乱,以至于你可能已经引入了脚本。 如果您预期每个看到该页面的人都能够遵循目前的基本逻辑,那么这是一个不错的select。

    纯EL解决scheme

    如果您已经使用EL 3.0(Java EE 7 / Servlet 3.1),请使用对stream和lambdas的新支持:

    ${person.name}${person.age} ${personList.stream().map(person -> person.age).sum()}

    JSP EL函数

    输出总量而不将脚本代码引入JSP的另一种方法是使用EL函数。 EL函数允许您在公共类中调用公共静态方法。 例如,如果您想迭代您的集合并对这些值进行求和,则可以在公共类(可能称为PersonUtils)中定义一个名为sum(List people)的公共静态方法。 在你的tld文件中,你可以放置下面的声明:

    sumcom.example.PersonUtilsint sum(java.util.List people)

    在你的JSP中,你会写:

    ...

    JSP EL函数有几个好处。 它们允许您使用现有的Java方法,而无需编写特定的UI(自定义标签库)。 它们也很紧凑,不会混淆非编程导向的人。

    自定义标签

    还有一个select是推出自己的自定义标签。 这个选项将涉及最多的设置,但会给你我觉得你实际上寻找,绝对没有scriptlet。 使用简单的自定义标签的一个很好的教程可以在http://java.sun.com/j2ee/tutorial/1_3-fcs/doc/JSPTags5.html#74701find

    涉及的步骤包括子类别TagSupport:

    public PersonSumTag extends TagSupport { private List personList; public List getPersonList(){ return personList; } public void setPersonList(List personList){ this.personList = personList; } public int doStartTag() throws JspException { try { int sum = 0; for(Iterator it = personList.iterator(); it.hasNext()){ Person p = (Person)it.next(); sum+=p.getAge(); } pageContext.getOut().print(""+sum); } catch (Exception ex) { throw new JspTagException("SimpleTag: " + ex.getMessage()); } return SKIP_BODY; } public int doEndTag() { return EVAL_PAGE; } }

    在tld文件中定义标签:

    personSumexample.PersonSumTagempty ... personListtruetruejava.util.List ...

    在JSP的顶部声明taglib:

    并使用标签:

    ${person.name}${person.age}

    显示标签

    正如前面提到的zmf,你也可以使用display标签,尽pipe你需要包含相应的库:

    展开全文
  • 源码统计器v1.1

    2006-03-16 00:00:00
    ◆ 在“搜索文件夹”组合框中输入你需要进行统计的文件所在的文件夹(如: d:study),点击下拉框可以选择近几次进行统计的文件夹。如果你手动输入的文件夹不在下拉框中,软件在统计开始后自动将该文件夹加入。点击...
  • 算法的优点的是通俗易懂,缺点是需要两次扫描图像,效率不高。 区域生长法利用区域生长的思想,一次生长过程可以标记一整个连通区,只需对图像进行一次扫描就能标记出所有连通区。算法描述如下: 输入待标记图像...
  • ◆ 在“搜索文件夹”组合框中输入你需要进行统计的文件所在的文件夹(如: d:\study),点击下拉框可以选择近几次进行统计的文件夹。如果你手动输入的文件夹不在下拉框中,软件在统计开始后自动将该文件夹加入。点击...
  • 二值图像统计连通区域C语言版

    千次阅读 2016-02-25 21:20:57
    该算法中,按从左至右、从上至下的顺序,对整幅图像进行扫描,通过比较每个前景像素的邻域...算法的优点的是通俗易懂,缺点是需要两次扫描图像,效率不高。区域生长法利用区域生长的思想,一次生长过程可以标记一整个连

    http://www.bkjia.com/Javabc/771817.html

    连通区标记是最基本的图像处理算法之一。该算法中,按从左至右、从上至下的顺序,对整幅图像进行扫描,通过比较每个前景像素的邻域进行连通区标记,并创建等效标记列表。最后,合并等效标记列表,并再次扫描图像以更新标记。算法的优点的是通俗易懂,缺点是需要两次扫描图像,效率不高。

    区域生长法利用区域生长的思想,一次生长过程可以标记一整个连通区,只需对图像进行一次扫描就能标记出所有连通区。算法描述如下:
    输入待标记图像bitmap,初始化一个与输入图像同样尺寸的标记矩阵labelmap,一个队列queue以及标记计数labelIndex;按从左至右、从上至下的顺序扫描bitmap,当扫描到一个未被标记的前景像素p时,labelIndex加1,并在labelmap中标记p(相应点的值赋为labelIndex),同时,扫描p的八邻域点,若存在未被标记的前景像素,则在labelmap中进行标记,并放入queue中,作为区域生长的种子;当queue不为空时,从queue中取出一个生长种子点p1,扫描p1的八邻域点,若存在未被标记过的前景像素,则在labelmap中进行标记,并放入queue中;重复3直至queue为空,一个连通区标记完成;转到2,直至整幅图像被扫描完毕,得到标记矩阵labelmap和连通区的个数labelIndex。

    该算法最坏情况下,将对每个像素点都进行一次八邻域搜索,算法复杂度为O(n)。

    typedef struct QNode{
        int data;
        struct QNode *next;
    }QNode;
    
    typedef struct Queue{
        struct QNode* first;
        struct QNode* last;
    }Queue;
    
    void PushQueue(Queue *queue, int data){
        QNode *p = NULL;
        p = (QNode*)malloc(sizeof(QNode));
        p->data = data;
        if(queue->first == NULL){
            queue->first = p;
            queue->last = p;
            p->next = NULL;
        }
        else{
            p->next = NULL;
            queue->last->next = p;
            queue->last = p;
        }
    }
    
    int PopQueue(Queue *queue){
        QNode *p = NULL;
        int data;
        if(queue->first == NULL){
            return -1;
        }
        p = queue->first;
        data = p->data;
        if(queue->first->next == NULL){
            queue->first = NULL;
            queue->last = NULL;
        }
        else{
            queue->first = p->next;
        }
        free(p);
        return data;
    }
    
    static int NeighborDirection[8][2] = {{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1}};
    
    void SearchNeighbor(unsigned char *bitmap, int width, int height, int *labelmap, 
                        int labelIndex, int pixelIndex, Queue *queue){
        int searchIndex, i, length;
        labelmap[pixelIndex] = labelIndex;
        length = width * height;
        for(i = 0;i < 8;i++){
            searchIndex = pixelIndex + NeighborDirection[i][0] * width + NeighborDirection[i][1];
            if(searchIndex > 0 && searchIndex < length && 
                bitmap[searchIndex] == 255 && labelmap[searchIndex] == 0){
                labelmap[searchIndex] = labelIndex;
                PushQueue(queue, searchIndex);
            }
        }
    }
    
    int ConnectedComponentLabeling(unsigned char *bitmap, int width, int height, int *labelmap){
        int cx, cy, index, popIndex, labelIndex = 0;
        Queue *queue = NULL;
        queue = (Queue*)malloc(sizeof(Queue));
        queue->first = NULL;
            queue->last = NULL;
        memset(labelmap, 0, width * height);
        for(cy = 1; cy < height - 1; cy++){
            for(cx = 1; cx < width - 1; cx++){
                index = cy * width + cx;
                if(bitmap[index] == 255 && labelmap[index] == 0){
                    labelIndex++;
                    SearchNeighbor(bitmap, width, height, labelmap, labelIndex, index, queue);
    
                    popIndex = PopQueue(queue);
                    while(popIndex > -1){
                    SearchNeighbor(bitmap, width, height, labelmap, labelIndex, popIndex, queue);
                        popIndex = PopQueue(queue);
                    }
                }
            }
        }
        free(queue);
        return labelIndex;
    }
    展开全文
  • 为此目的,t-Digest优于以前的摘要的优点是,t-Digest可处理具有完整浮点分辨率的数据。 由t-摘要产生的分位数估计的准确性可能比以前的摘要算法产生的分位数估计的准确性高几个数量级。 提供了从累积分布中创建和...
  • 常见推荐算法总结

    2018-08-04 14:19:24
    通过对商品本身特征抽取、建立相似性列表、再利用用户对商品反馈(购物车、收藏),进行推荐 优点:可解释、用户独立性强 缺点:难以挖掘用户隐藏兴趣、个性化低、对新用户存在冷启动问题、特征抽取工作量大...
  • Redis数据结构

    2018-09-13 11:39:57
    ⑥.HyperLogLog (Redis在2.8.9加入的HyperLogLog结构,是用来做基数统计的算法,其优点是在输入元素的数量或者体积非常大的时候,计算基数所需的空间总是固定的并且很小,在Redis中每个 HyperLogLog 键只需要花...
  • MySQL基本操作及命令4基本操作 基本操作 #进阶4:常见函数 /* 功能:类似于Java方法,将一组逻辑语句封装在方法体中,... 功能:做统计使用,又称为统计函数,聚合函数,组函数 */ #一、字符函数 #1.length 获
  • fping使用方法

    千次阅读 2011-08-02 21:34:09
    fping 的优点: 1. 可以一次ping多个主机 2. 可以从主机列表文件ping 3. 结果清晰 便于脚本处理 4. 速度快   有用的参数: -g ping 网段 -s 显示统计 -r 1 设置重试次数   Usage: fping [options
  • top作为日常管理工作中最常用也是最重要Linux系统监控工具之一,可以动态观察系统进程状况。但其缺点就是只支持键盘操作,显示也... 2) 可以横向或纵向滚动浏览进程列表,以查看所有进程和完整命令行; 3) 杀掉.
  • 1. 数据透视含义 数据透视表是用来从excel数据列表、关系数据库文件或者OLAP多维数据集等数据源的特定字段中总结信息的分析工具...数据透视表有机地综合了数据排序、筛选和分类汇总等数据分析方法的优点,可以方便地调
  • htop、dstat、top、ps命令使用一、htop1、htop介绍 htop是Linux系统下一个基本文本模式... htop命令优点: (1) 快速查看关键性能统计数据,如CPU(多核布局)、内存/交换使用; (2) 可以横向或纵向滚动浏览进程列表...
  • JSP具有以下的优点: 1、将业务层与表示层分离:使用JSP技术,网络开发人员可充分使用HTML来设计页面显示部分(如字体颜色等),并使用JSP指令或者JAVA程序片段来生成网页上的动态内容; 2、能够跨平台:JSP支持绝...
  • *始终确保您被复制出去消息*预览以查看BB代码样子* YPT正文*密件抄送消息中收件人姓名列表培训:*添加了快速编辑Scout Youth培训功能*添加了受过训练成人领导者从培训报告中导出为CSV *添加YPT培训报告,...
  • 这个系列就要要来合并上面两个优点整合起来,将家里会用到设备全部无线化,又有统一界面可以管理。既然讲到无线,当然要提到最适合DIY应用LoRa无线技术。LoRa有4大优点: 1.使用免授权费就可以使用Sub1GHz...
  • 统计发现,近期大部分使用极光漏洞挂马,这...今天新增被挂马知名×××网站列表(部分)马鞍山市住房公积金管理中心hxxp://www.masgjj.gov.cn/type.asp?typeid=40成都市龙泉驿区房管局hxxp://www.lqfgj.com/index...
  • 统计发现,近期大部分...今天新增被挂马知名房产网站列表(部分)马鞍山市住房公积金管理中心hxxp://www.masgjj.gov.cn/type.asp?typeid=40成都市龙泉驿区房管局hxxp://www.lqfgj.com/index.asp深圳市海王房地产...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 192
精华内容 76
关键字:

列表统计的优点